< Module matchEval:list.

 < Prove_Constraint matchEval:host:proj_expr_unique.

Subgoal 1:

Variables: E2 Ty
PrA : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
PrB : |{expr}- nil Ty ~~> E2
IsE : is_expr (nil Ty)
============================
 recBuild (consRecFieldExprs "null" true nilRecFieldExprs) = E2

 < case PrB.

Subgoal 1:

Variables: Ty
PrA : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
============================
 recBuild (consRecFieldExprs "null" true nilRecFieldExprs) = recBuild (consRecFieldExprs "null" true nilRecFieldExprs)

 < search.

Subgoal 2:

Variables: E2 E4 E3
PrA : |{expr}- cons E3 E4 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E3 (consRecFieldExprs "tail" E4 nilRecFieldExprs)))
PrB : |{expr}- cons E3 E4 ~~> E2
IsE : is_expr (cons E3 E4)
============================
 recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E3 (consRecFieldExprs "tail" E4 nilRecFieldExprs))) = E2

 < case PrB.

Subgoal 2:

Variables: E4 E3
PrA : |{expr}- cons E3 E4 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E3 (consRecFieldExprs "tail" E4 nilRecFieldExprs)))
IsE : is_expr (cons E3 E4)
============================
 recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E3 (consRecFieldExprs "tail" E4 nilRecFieldExprs))) = recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E3 (consRecFieldExprs "tail" E4 nilRecFieldExprs)))

 < search.

Subgoal 3:

Variables: E2 E3
PrA : |{expr}- null E3 ~~> recFieldAccess E3 "null"
PrB : |{expr}- null E3 ~~> E2
IsE : is_expr (null E3)
============================
 recFieldAccess E3 "null" = E2

 < case PrB.

Subgoal 3:

Variables: E3
PrA : |{expr}- null E3 ~~> recFieldAccess E3 "null"
IsE : is_expr (null E3)
============================
 recFieldAccess E3 "null" = recFieldAccess E3 "null"

 < search.

Subgoal 4:

Variables: E2 E3
PrA : |{expr}- head E3 ~~> recFieldAccess E3 "head"
PrB : |{expr}- head E3 ~~> E2
IsE : is_expr (head E3)
============================
 recFieldAccess E3 "head" = E2

 < case PrB.

Subgoal 4:

Variables: E3
PrA : |{expr}- head E3 ~~> recFieldAccess E3 "head"
IsE : is_expr (head E3)
============================
 recFieldAccess E3 "head" = recFieldAccess E3 "head"

 < search.

Subgoal 5:

Variables: E2 E3
PrA : |{expr}- tail E3 ~~> recFieldAccess E3 "tail"
PrB : |{expr}- tail E3 ~~> E2
IsE : is_expr (tail E3)
============================
 recFieldAccess E3 "tail" = E2

 < case PrB.

Subgoal 5:

Variables: E3
PrA : |{expr}- tail E3 ~~> recFieldAccess E3 "tail"
IsE : is_expr (tail E3)
============================
 recFieldAccess E3 "tail" = recFieldAccess E3 "tail"

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_expr_is.

Subgoal 1:

Variables: Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
============================
 is_expr (recBuild (consRecFieldExprs "null" true nilRecFieldExprs))

 < case IsE.

Subgoal 1:

Variables: Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
H1 : is_typ Ty
============================
 is_expr (recBuild (consRecFieldExprs "null" true nilRecFieldExprs))

 < search 8.

Subgoal 2:

Variables: E2 E1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsE : is_expr (cons E1 E2)
============================
 is_expr (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs))))

 < case IsE.

Subgoal 2:

Variables: E2 E1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
H1 : is_expr E1
H2 : is_expr E2
============================
 is_expr (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs))))

 < search 10.

Subgoal 3:

Variables: E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsE : is_expr (null E1)
============================
 is_expr (recFieldAccess E1 "null")

 < case IsE.

Subgoal 3:

Variables: E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
H1 : is_expr E1
============================
 is_expr (recFieldAccess E1 "null")

 < search 7.

Subgoal 4:

Variables: E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
IsE : is_expr (head E1)
============================
 is_expr (recFieldAccess E1 "head")

 < case IsE.

Subgoal 4:

Variables: E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
H1 : is_expr E1
============================
 is_expr (recFieldAccess E1 "head")

 < search 7.

Subgoal 5:

Variables: E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
IsE : is_expr (tail E1)
============================
 is_expr (recFieldAccess E1 "tail")

 < case IsE.

Subgoal 5:

Variables: E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
H1 : is_expr E1
============================
 is_expr (recFieldAccess E1 "tail")

 < search 7.

Proof completed.

 < Prove_Constraint matchEval:host:proj_stmt_unique.

Subgoal 1:

Variables: L1 L2 S2 Hold L SaveE SaveI E I
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
PrB : L2 |{stmt}- listUpdate L I E ~~> S2
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
============================
 scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))))))) = S2

 < PrB: case PrB.

Subgoal 1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
============================
 scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))))))) = scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))

 < assert forall X,
     mem X (L::L2) -> mem X (L::L1).

Subgoal 1.1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
============================
 forall X, mem X (L::L2) -> mem X (L::L1)

 < intros M.

Subgoal 1.1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1 X
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
M : mem X (L::L2)
============================
 mem X (L::L1)

 < M: case M.

Subgoal 1.1.1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
============================
 mem L (L::L1)

 < search.

Subgoal 1.1.2:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1 X
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
M : mem X L2
============================
 mem X (L::L1)

 < apply Rel21 to M.

Subgoal 1.1.2:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1 X
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
M : mem X L2
H1 : mem X L1
============================
 mem X (L::L1)

 < search.

Subgoal 1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
============================
 scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))))))) = scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))

 < assert forall X,
     mem X (L::L1) -> mem X (L::L2).

Subgoal 1.2:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
============================
 forall X, mem X (L::L1) -> mem X (L::L2)

 < intros M.

Subgoal 1.2:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1 X
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
M : mem X (L::L1)
============================
 mem X (L::L2)

 < M: case M.

Subgoal 1.2.1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
============================
 mem L (L::L2)

 < search.

Subgoal 1.2.2:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1 X
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
M : mem X L1
============================
 mem X (L::L2)

 < apply Rel12 to M.

Subgoal 1.2.2:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1 X
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
M : mem X L1
H2 : mem X L2
============================
 mem X (L::L2)

 < search.

Subgoal 1:

Variables: L1 L2 Hold L SaveE SaveI E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
H2 : forall X, mem X (L::L1) -> mem X (L::L2)
============================
 scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))))))) = scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))

 < apply fresh_name_unique_mems to PrA1 PrB _ _.

Subgoal 1:

Variables: L1 L2 Hold L SaveE E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI1
PrA2 : fresh_name "Hold" (L::L1) Hold
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
H2 : forall X, mem X (L::L1) -> mem X (L::L2)
============================
 scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))))))) = scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))

 < apply fresh_name_unique_mems to PrA2 PrB1 _ _.

Subgoal 1:

Variables: L1 L2 L SaveE E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI1
PrA2 : fresh_name "Hold" (L::L1) Hold1
PrA3 : fresh_name "E" (L::L1) SaveE
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
H2 : forall X, mem X (L::L1) -> mem X (L::L2)
============================
 scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1))))))))))) = scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))

 < apply fresh_name_unique_mems to PrA3 PrB2 _ _.

Subgoal 1:

Variables: L1 L2 L E I Hold1 SaveE1 SaveI1
PrA : L1 |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))
IsS : is_stmt (listUpdate L I E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "I" (L::L1) SaveI1
PrA2 : fresh_name "Hold" (L::L1) Hold1
PrA3 : fresh_name "E" (L::L1) SaveE1
PrB : fresh_name "I" (L::L2) SaveI1
PrB1 : fresh_name "Hold" (L::L2) Hold1
PrB2 : fresh_name "E" (L::L2) SaveE1
H1 : forall X, mem X (L::L2) -> mem X (L::L1)
H2 : forall X, mem X (L::L1) -> mem X (L::L2)
============================
 scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1))))))))))) = scopeStmt (seq (declare intTy SaveI1 I) (seq (declare intTy SaveE1 E) (seq (assign SaveI1 (name SaveI1)) (seq (declare intTy Hold1 (nil intTy)) (seq (while (greater (name SaveI1) (num 0)) (seq (assign SaveI1 (minus (name SaveI1) (num 1))) (seq (assign Hold1 (cons (head (name L)) (name Hold1))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE1) (tail (name L)))) (while (not (null (name Hold1))) (seq (assign L (cons (head (name Hold1)) (name L))) (assign Hold1 (tail (name Hold1)))))))))))

 < search.

Subgoal 2:

Variables: L1 L2 S2 Body SaveL X L
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
PrB : L2 |{stmt}- listForeach X L Body ~~> S2
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
============================
 scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))) = S2

 < PrB: case PrB.

Subgoal 2:

Variables: L1 L2 Body SaveL X L SaveL1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
============================
 scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))) = scopeStmt (seq (declare intTy SaveL1 L) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))))

 < apply fresh_name_unique_mems to PrA1 PrB _ _.

Subgoal 2.1:

Variables: L1 L2 Body SaveL X L SaveL1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
============================
 forall X1, mem X1 (X::L2) -> mem X1 (X::L1)

 < intros M.

Subgoal 2.1:

Variables: L1 L2 Body SaveL X L SaveL1 X1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
M : mem X1 (X::L2)
============================
 mem X1 (X::L1)

 < M: case M.

Subgoal 2.1.1:

Variables: L1 L2 Body SaveL X L SaveL1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
============================
 mem X (X::L1)

 < search.

Subgoal 2.1.2:

Variables: L1 L2 Body SaveL X L SaveL1 X1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
M : mem X1 L2
============================
 mem X1 (X::L1)

 < apply Rel21 to M.

Subgoal 2.1.2:

Variables: L1 L2 Body SaveL X L SaveL1 X1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
M : mem X1 L2
H1 : mem X1 L1
============================
 mem X1 (X::L1)

 < search.

Subgoal 2.2:

Variables: L1 L2 Body SaveL X L SaveL1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
============================
 forall X1, mem X1 (X::L1) -> mem X1 (X::L2)

 < intros M.

Subgoal 2.2:

Variables: L1 L2 Body SaveL X L SaveL1 X1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
M : mem X1 (X::L1)
============================
 mem X1 (X::L2)

 < M: case M.

Subgoal 2.2.1:

Variables: L1 L2 Body SaveL X L SaveL1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
============================
 mem X (X::L2)

 < search.

Subgoal 2.2.2:

Variables: L1 L2 Body SaveL X L SaveL1 X1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
M : mem X1 L1
============================
 mem X1 (X::L2)

 < apply Rel12 to M.

Subgoal 2.2.2:

Variables: L1 L2 Body SaveL X L SaveL1 X1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL
PrB : fresh_name "L" (X::L2) SaveL1
M : mem X1 L1
H1 : mem X1 L2
============================
 mem X1 (X::L2)

 < search.

Subgoal 2:

Variables: L1 L2 Body X L SaveL1
PrA : L1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL1 L) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))))
IsS : is_stmt (listForeach X L Body)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
PrA1 : fresh_name "L" (X::L1) SaveL1
PrB : fresh_name "L" (X::L2) SaveL1
============================
 scopeStmt (seq (declare intTy SaveL1 L) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body)))) = scopeStmt (seq (declare intTy SaveL1 L) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))))

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_stmt_is.

Subgoal 1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L1 I E)
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
============================
 is_stmt (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold))))))))))))

 < case IsS.

Subgoal 1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
============================
 is_stmt (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold))))))))))))

 < apply fresh_name_is to _ Pr1.

Subgoal 1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
H4 : is_string SaveI
============================
 is_stmt (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold))))))))))))

 < assert is_string "Hold".

Subgoal 1.1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
H4 : is_string SaveI
============================
 is_string "Hold"

 < search 6.

Subgoal 1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
H4 : is_string SaveI
H5 : is_string "Hold"
============================
 is_stmt (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold))))))))))))

 < apply fresh_name_is to _ Pr2.

Subgoal 1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
H4 : is_string SaveI
H5 : is_string "Hold"
H6 : is_string Hold
============================
 is_stmt (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold))))))))))))

 < apply fresh_name_is to _ Pr3.

Subgoal 1:

Variables: L Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
H4 : is_string SaveI
H5 : is_string "Hold"
H6 : is_string Hold
H7 : is_string SaveE
============================
 is_stmt (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold))))))))))))

 < search 20.

Subgoal 2:

Variables: L Body SaveL X L1
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L1 Body)
IsL : is_list is_string L
Pr1 : fresh_name "L" (X::L) SaveL
============================
 is_stmt (scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))))

 < case IsS.

Subgoal 2:

Variables: L Body SaveL X L1
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsL : is_list is_string L
Pr1 : fresh_name "L" (X::L) SaveL
H1 : is_string X
H2 : is_expr L1
H3 : is_stmt Body
============================
 is_stmt (scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))))

 < apply fresh_name_is to _ Pr1.

Subgoal 2:

Variables: L Body SaveL X L1
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsL : is_list is_string L
Pr1 : fresh_name "L" (X::L) SaveL
H1 : is_string X
H2 : is_expr L1
H3 : is_stmt Body
H4 : is_string SaveL
============================
 is_stmt (scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))))

 < search 10.

Proof completed.

 < Prove_Constraint matchEval:host:proj_stmt_other.

Subgoal 1:

Variables: L L' Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsS : is_stmt (listUpdate L1 I E)
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
============================
 exists S'', L' |{stmt}- listUpdate L1 I E ~~> S''

 < case IsS.

Subgoal 1:

Variables: L L' Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
============================
 exists S'', L' |{stmt}- listUpdate L1 I E ~~> S''

 < Is': assert is_list is_string (L1::L').

Subgoal 1:

Variables: L L' Hold L1 SaveE SaveI E I
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
Is' : is_list is_string (L1::L')
============================
 exists S'', L' |{stmt}- listUpdate L1 I E ~~> S''

 < apply fresh_name_exists to _ Is' with
     Base = "I".

Subgoal 1:

Variables: L L' Hold L1 SaveE SaveI E I F
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
Is' : is_list is_string (L1::L')
H4 : fresh_name "I" (L1::L') F
============================
 exists S'', L' |{stmt}- listUpdate L1 I E ~~> S''

 < apply fresh_name_exists to _ Is' with
     Base = "Hold".

Subgoal 1.1:

Variables: L L' Hold L1 SaveE SaveI E I F
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
Is' : is_list is_string (L1::L')
H4 : fresh_name "I" (L1::L') F
============================
 is_string "Hold"

 < search 6.

Subgoal 1:

Variables: L L' Hold L1 SaveE SaveI E I F F1
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
Is' : is_list is_string (L1::L')
H4 : fresh_name "I" (L1::L') F
H5 : fresh_name "Hold" (L1::L') F1
============================
 exists S'', L' |{stmt}- listUpdate L1 I E ~~> S''

 < apply fresh_name_exists to _ Is' with
     Base = "E".

Subgoal 1:

Variables: L L' Hold L1 SaveE SaveI E I F F1 F2
Pr : L |{stmt}- listUpdate L1 I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L1)) (name Hold))) (assign L1 (tail (name L1)))))) (seq (assign L1 (cons (name SaveE) (tail (name L1)))) (while (not (null (name Hold))) (seq (assign L1 (cons (head (name Hold)) (name L1))) (assign Hold (tail (name Hold)))))))))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "I" (L1::L) SaveI
Pr2 : fresh_name "Hold" (L1::L) Hold
Pr3 : fresh_name "E" (L1::L) SaveE
H1 : is_string L1
H2 : is_expr I
H3 : is_expr E
Is' : is_list is_string (L1::L')
H4 : fresh_name "I" (L1::L') F
H5 : fresh_name "Hold" (L1::L') F1
H6 : fresh_name "E" (L1::L') F2
============================
 exists S'', L' |{stmt}- listUpdate L1 I E ~~> S''

 < search.

Subgoal 2:

Variables: L L' Body SaveL X L1
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsS : is_stmt (listForeach X L1 Body)
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "L" (X::L) SaveL
============================
 exists S'', L' |{stmt}- listForeach X L1 Body ~~> S''

 < case IsS.

Subgoal 2:

Variables: L L' Body SaveL X L1
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "L" (X::L) SaveL
H1 : is_string X
H2 : is_expr L1
H3 : is_stmt Body
============================
 exists S'', L' |{stmt}- listForeach X L1 Body ~~> S''

 < Is': assert is_list is_string (X::L').

Subgoal 2:

Variables: L L' Body SaveL X L1
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "L" (X::L) SaveL
H1 : is_string X
H2 : is_expr L1
H3 : is_stmt Body
Is' : is_list is_string (X::L')
============================
 exists S'', L' |{stmt}- listForeach X L1 Body ~~> S''

 < apply fresh_name_exists to _ Is' with
     Base = "L".

Subgoal 2:

Variables: L L' Body SaveL X L1 F
Pr : L |{stmt}- listForeach X L1 Body ~~> scopeStmt (seq (declare intTy SaveL L1) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
IsL : is_list is_string L
IsL' : is_list is_string L'
Pr1 : fresh_name "L" (X::L) SaveL
H1 : is_string X
H2 : is_expr L1
H3 : is_stmt Body
Is' : is_list is_string (X::L')
H4 : fresh_name "L" (X::L') F
============================
 exists S'', L' |{stmt}- listForeach X L1 Body ~~> S''

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_fun_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_fun_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_param_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_param_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_program_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_program_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_typ_unique.

Variables: T2 T3
PrA : |{typ}- listTy T3 ~~> recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T3 (consRecFieldTys "tail" (listTy T3) nilRecFieldTys)))
PrB : |{typ}- listTy T3 ~~> T2
IsT : is_typ (listTy T3)
============================
 recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T3 (consRecFieldTys "tail" (listTy T3) nilRecFieldTys))) = T2

 < case PrB.

Variables: T3
PrA : |{typ}- listTy T3 ~~> recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T3 (consRecFieldTys "tail" (listTy T3) nilRecFieldTys)))
IsT : is_typ (listTy T3)
============================
 recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T3 (consRecFieldTys "tail" (listTy T3) nilRecFieldTys))) = recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T3 (consRecFieldTys "tail" (listTy T3) nilRecFieldTys)))

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_typ_is.

Variables: T1
Pr : |{typ}- listTy T1 ~~> recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T1 (consRecFieldTys "tail" (listTy T1) nilRecFieldTys)))
IsT : is_typ (listTy T1)
============================
 is_typ (recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T1 (consRecFieldTys "tail" (listTy T1) nilRecFieldTys))))

 < case IsT.

Variables: T1
Pr : |{typ}- listTy T1 ~~> recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T1 (consRecFieldTys "tail" (listTy T1) nilRecFieldTys)))
H1 : is_typ T1
============================
 is_typ (recTy (consRecFieldTys "null" boolTy (consRecFieldTys "head" T1 (consRecFieldTys "tail" (listTy T1) nilRecFieldTys))))

 < search 11.

Proof completed.

 < Prove_Constraint matchEval:host:proj_value_unique.

Subgoal 1:

Variables: V2
PrA : |{value}- nilVal ~~> recVal [("null", trueVal)]
PrB : |{value}- nilVal ~~> V2
IsV : is_value nilVal
============================
 recVal [("null", trueVal)] = V2

 < case PrB.

Subgoal 1:

PrA : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
============================
 recVal [("null", trueVal)] = recVal [("null", trueVal)]

 < search.

Subgoal 2:

Variables: V2 V4 V3
PrA : |{value}- consVal V3 V4 ~~> recVal [("null", falseVal), ("head", V3), ("tail", V4)]
PrB : |{value}- consVal V3 V4 ~~> V2
IsV : is_value (consVal V3 V4)
============================
 recVal [("null", falseVal), ("head", V3), ("tail", V4)] = V2

 < case PrB.

Subgoal 2:

Variables: V4 V3
PrA : |{value}- consVal V3 V4 ~~> recVal [("null", falseVal), ("head", V3), ("tail", V4)]
IsV : is_value (consVal V3 V4)
============================
 recVal [("null", falseVal), ("head", V3), ("tail", V4)] = recVal [("null", falseVal), ("head", V3), ("tail", V4)]

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_value_is.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
============================
 is_value (recVal [("null", trueVal)])

 < search 10.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
============================
 is_value (recVal [("null", falseVal), ("head", V1), ("tail", V2)])

 < case IsV.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
H1 : is_value V1
H2 : is_value V2
============================
 is_value (recVal [("null", falseVal), ("head", V1), ("tail", V2)])

 < search 20.

Proof completed.

 < Add_Proj_Rel matchEval:host:is_expr,
   matchEval:host:is_args,
   matchEval:host:is_recFieldExprs.

Proof completed.

 < Prove_Ext_Ind matchEval:host:is_expr,
   matchEval:host:is_args,
   matchEval:host:is_recFieldExprs.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 1.20:

Variables: Typ
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (nil Typ) @
R1 : is_typ Typ
============================
 <is_expr {P}> (nil Typ)

 < search 10.

Subgoal 1.21:

Variables: Expr Expr1
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (cons Expr1 Expr) @
R1 : is_expr Expr1 *
R2 : is_expr Expr *
============================
 <is_expr {P}> (cons Expr1 Expr)

 < apply IH to R1.

Subgoal 1.21:

Variables: Expr Expr1
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (cons Expr1 Expr) @
R1 : is_expr Expr1 *
R2 : is_expr Expr *
H1 : <is_expr {P}> Expr1
============================
 <is_expr {P}> (cons Expr1 Expr)

 < apply IH to R2.

Subgoal 1.21:

Variables: Expr Expr1
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (cons Expr1 Expr) @
R1 : is_expr Expr1 *
R2 : is_expr Expr *
H1 : <is_expr {P}> Expr1
H2 : <is_expr {P}> Expr
============================
 <is_expr {P}> (cons Expr1 Expr)

 < search 20.

Subgoal 1.22:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (head Expr) @
R1 : is_expr Expr *
============================
 <is_expr {P}> (head Expr)

 < apply IH to R1.

Subgoal 1.22:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (head Expr) @
R1 : is_expr Expr *
H1 : <is_expr {P}> Expr
============================
 <is_expr {P}> (head Expr)

 < search 10.

Subgoal 1.23:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (tail Expr) @
R1 : is_expr Expr *
============================
 <is_expr {P}> (tail Expr)

 < apply IH to R1.

Subgoal 1.23:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (tail Expr) @
R1 : is_expr Expr *
H1 : <is_expr {P}> Expr
============================
 <is_expr {P}> (tail Expr)

 < search 10.

Subgoal 1.24:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (null Expr) @
R1 : is_expr Expr *
============================
 <is_expr {P}> (null Expr)

 < apply IH to R1.

Subgoal 1.24:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (null Expr) @
R1 : is_expr Expr *
H1 : <is_expr {P}> Expr
============================
 <is_expr {P}> (null Expr)

 < search 10.

Proof completed.

 < Add_Proj_Rel matchEval:host:is_stmt.

Proof completed.

 < Prove_Ext_Ind matchEval:host:is_stmt.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 10:

Variables: Expr Expr1 S1
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < FrI: apply fresh_name_exists to _ _ with
          Base = "I" Names = [S1].

Subgoal 10:

Variables: Expr Expr1 S1 F
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < FrH: apply fresh_name_exists to _ _ with
          Base = "Hold" Names = [S1].

Subgoal 10.1:

Variables: Expr Expr1 S1 F
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
============================
 is_string "Hold"

 < search 7.

Subgoal 10:

Variables: Expr Expr1 S1 F F1
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < FrE: apply fresh_name_exists to _ _ with
          Base = "E" Names = [S1].

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < apply fresh_name_is to _ FrI.

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < apply fresh_name_is to _ FrE.

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < apply fresh_name_is to _ FrH.

Subgoal 10.2:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
============================
 is_string "Hold"

 < search 7.

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < assert [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (matchEval:list:nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1))))))))))).

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 <is_stmt {P}> (listUpdate S1 Expr1 Expr)

 < unfold .

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 exists A1 X_T,
   (is_string S1 /\ (is_expr Expr1 /\ is_expr Expr)) /\
   (A1 |{stmt}- listUpdate S1 Expr1 Expr ~~> X_T /\ <is_stmt {P}> X_T)

 < exists [],
   scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (matchEval:list:nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1))))))))))).

Subgoal 10:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 (is_string S1 /\ (is_expr Expr1 /\ is_expr Expr)) /\
 ([] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1))))))))))) /\
 <is_stmt {P}> (scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))))

 < split.

Subgoal 10.3:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 is_string S1

 < search.

Subgoal 10.4:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 is_expr Expr1

 < search.

Subgoal 10.5:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 is_expr Expr

 < search.

Subgoal 10.6:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))

 < search.

Subgoal 10.7:

Variables: Expr Expr1 S1 F F1 F2
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listUpdate S1 Expr1 Expr) @
R1 : is_string S1
R2 : is_expr Expr1
R3 : is_expr Expr
FrI : fresh_name "I" [S1] F
FrH : fresh_name "Hold" [S1] F1
FrE : fresh_name "E" [S1] F2
H1 : is_string F
H2 : is_string F2
H3 : is_string F1
H4 : [] |{stmt}- listUpdate S1 Expr1 Expr ~~> scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1)))))))))))
============================
 <is_stmt {P}> (scopeStmt (seq (declare intTy F Expr1) (seq (declare intTy F2 Expr) (seq (assign F (name F)) (seq (declare intTy F1 (nil intTy)) (seq (while (greater (name F) (num 0)) (seq (assign F (minus (name F) (num 1))) (seq (assign F1 (cons (head (name S1)) (name F1))) (assign S1 (tail (name S1)))))) (seq (assign S1 (cons (name F2) (tail (name S1)))) (while (not (null (name F1))) (seq (assign S1 (cons (head (name F1)) (name S1))) (assign F1 (tail (name F1))))))))))))

 < search 20.

Subgoal 11:

Variables: Stmt Expr S1
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listForeach S1 Expr Stmt) @
R1 : is_string S1
R2 : is_expr Expr
R3 : is_stmt Stmt *
============================
 <is_stmt {P}> (listForeach S1 Expr Stmt)

 < apply IH to R3.

Subgoal 11:

Variables: Stmt Expr S1
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listForeach S1 Expr Stmt) @
R1 : is_string S1
R2 : is_expr Expr
R3 : is_stmt Stmt *
H1 : <is_stmt {P}> Stmt
============================
 <is_stmt {P}> (listForeach S1 Expr Stmt)

 < Fr: apply fresh_name_exists to _ _ with
         Base = "L" Names = [S1].

Subgoal 11:

Variables: Stmt Expr S1 F
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listForeach S1 Expr Stmt) @
R1 : is_string S1
R2 : is_expr Expr
R3 : is_stmt Stmt *
H1 : <is_stmt {P}> Stmt
Fr : fresh_name "L" [S1] F
============================
 <is_stmt {P}> (listForeach S1 Expr Stmt)

 < apply fresh_name_is to _ Fr.

Subgoal 11:

Variables: Stmt Expr S1 F
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (listForeach S1 Expr Stmt) @
R1 : is_string S1
R2 : is_expr Expr
R3 : is_stmt Stmt *
H1 : <is_stmt {P}> Stmt
Fr : fresh_name "L" [S1] F
H2 : is_string F
============================
 <is_stmt {P}> (listForeach S1 Expr Stmt)

 < search 20.

Proof completed.

 < Prove matchEval:host:is_args_nilArgs_or_consArgs.

Proof completed.

 < Prove matchEval:host:is_recFieldExprs_nilRecFieldExprs_or_consRecFieldExprs.

Proof completed.

 < Prove matchEval:host:vars_unique.

Subgoal 1.20:

Variables: V2 Ty
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (nil Ty)
VarsA : vars (nil Ty) [] @
VarsB : vars (nil Ty) V2
============================
 [] = V2

 < case VarsB.

Subgoal 1.20:

Variables: Ty
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (nil Ty)
VarsA : vars (nil Ty) [] @
============================
 [] = []

 < search.

Subgoal 1.21:

Variables: V1 V2 V3 V4 E2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (cons E1 E2)
VarsA : vars (cons E1 E2) V1 @
VarsB : vars (cons E1 E2) V2
VarsA1 : vars E1 V3 *
VarsA2 : vars E2 V4 *
VarsA3 : V3 ++ V4 = V1
============================
 V1 = V2

 < case IsE.

Subgoal 1.21:

Variables: V1 V2 V3 V4 E2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (cons E1 E2) V1 @
VarsB : vars (cons E1 E2) V2
VarsA1 : vars E1 V3 *
VarsA2 : vars E2 V4 *
VarsA3 : V3 ++ V4 = V1
H1 : is_expr E1
H2 : is_expr E2
============================
 V1 = V2

 < VarsB: case VarsB.

Subgoal 1.21:

Variables: V1 V2 V3 V4 E2 E1 V5 V6
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (cons E1 E2) V1 @
VarsA1 : vars E1 V3 *
VarsA2 : vars E2 V4 *
VarsA3 : V3 ++ V4 = V1
H1 : is_expr E1
H2 : is_expr E2
VarsB : vars E1 V5
VarsB1 : vars E2 V6
VarsB2 : V5 ++ V6 = V2
============================
 V1 = V2

 < apply IH to _ VarsA1 VarsB.

Subgoal 1.21:

Variables: V1 V2 V4 E2 E1 V5 V6
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (cons E1 E2) V1 @
VarsA1 : vars E1 V5 *
VarsA2 : vars E2 V4 *
VarsA3 : V5 ++ V4 = V1
H1 : is_expr E1
H2 : is_expr E2
VarsB : vars E1 V5
VarsB1 : vars E2 V6
VarsB2 : V5 ++ V6 = V2
============================
 V1 = V2

 < apply IH to _ VarsA2 VarsB1.

Subgoal 1.21:

Variables: V1 V2 E2 E1 V5 V6
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (cons E1 E2) V1 @
VarsA1 : vars E1 V5 *
VarsA2 : vars E2 V6 *
VarsA3 : V5 ++ V6 = V1
H1 : is_expr E1
H2 : is_expr E2
VarsB : vars E1 V5
VarsB1 : vars E2 V6
VarsB2 : V5 ++ V6 = V2
============================
 V1 = V2

 < apply append_unique to VarsA3 VarsB2.

Subgoal 1.21:

Variables: V2 E2 E1 V5 V6
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (cons E1 E2) V2 @
VarsA1 : vars E1 V5 *
VarsA2 : vars E2 V6 *
VarsA3 : V5 ++ V6 = V2
H1 : is_expr E1
H2 : is_expr E2
VarsB : vars E1 V5
VarsB1 : vars E2 V6
VarsB2 : V5 ++ V6 = V2
============================
 V2 = V2

 < search.

Subgoal 1.22:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (head E1)
VarsA : vars (head E1) V1 @
VarsB : vars (head E1) V2
VarsA1 : vars E1 V1 *
============================
 V1 = V2

 < case IsE.

Subgoal 1.22:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (head E1) V1 @
VarsB : vars (head E1) V2
VarsA1 : vars E1 V1 *
H1 : is_expr E1
============================
 V1 = V2

 < VarsB: case VarsB.

Subgoal 1.22:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (head E1) V1 @
VarsA1 : vars E1 V1 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V1 = V2

 < apply IH to _ VarsA1 VarsB.

Subgoal 1.22:

Variables: V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (head E1) V2 @
VarsA1 : vars E1 V2 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V2 = V2

 < search.

Subgoal 1.23:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (tail E1)
VarsA : vars (tail E1) V1 @
VarsB : vars (tail E1) V2
VarsA1 : vars E1 V1 *
============================
 V1 = V2

 < case IsE.

Subgoal 1.23:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (tail E1) V1 @
VarsB : vars (tail E1) V2
VarsA1 : vars E1 V1 *
H1 : is_expr E1
============================
 V1 = V2

 < VarsB: case VarsB.

Subgoal 1.23:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (tail E1) V1 @
VarsA1 : vars E1 V1 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V1 = V2

 < apply IH to _ VarsA1 VarsB.

Subgoal 1.23:

Variables: V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (tail E1) V2 @
VarsA1 : vars E1 V2 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V2 = V2

 < search.

Subgoal 1.24:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (null E1)
VarsA : vars (null E1) V1 @
VarsB : vars (null E1) V2
VarsA1 : vars E1 V1 *
============================
 V1 = V2

 < case IsE.

Subgoal 1.24:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (null E1) V1 @
VarsB : vars (null E1) V2
VarsA1 : vars E1 V1 *
H1 : is_expr E1
============================
 V1 = V2

 < VarsB: case VarsB.

Subgoal 1.24:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (null E1) V1 @
VarsA1 : vars E1 V1 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V1 = V2

 < apply IH to _ VarsA1 VarsB.

Subgoal 1.24:

Variables: V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (null E1) V2 @
VarsA1 : vars E1 V2 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V2 = V2

 < search.

Proof completed.

 < Prove matchEval:host:vars_is.

Subgoal 1.20:

Variables: Ty
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
IsE : is_expr (nil Ty)
V : vars (nil Ty) [] @
============================
 is_list is_string []

 < search.

Subgoal 1.21:

Variables: V V2 V3 E2 E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
IsE : is_expr (cons E1 E2)
V : vars (cons E1 E2) V @
V1 : vars E1 V2 *
V2 : vars E2 V3 *
V3 : V2 ++ V3 = V
============================
 is_list is_string V

 < case IsE.

Subgoal 1.21:

Variables: V V2 V3 E2 E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (cons E1 E2) V @
V1 : vars E1 V2 *
V2 : vars E2 V3 *
V3 : V2 ++ V3 = V
H1 : is_expr E1
H2 : is_expr E2
============================
 is_list is_string V

 < apply IH to _ V1.

Subgoal 1.21:

Variables: V V2 V3 E2 E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (cons E1 E2) V @
V1 : vars E1 V2 *
V2 : vars E2 V3 *
V3 : V2 ++ V3 = V
H1 : is_expr E1
H2 : is_expr E2
H3 : is_list is_string V2
============================
 is_list is_string V

 < apply IH to _ V2.

Subgoal 1.21:

Variables: V V2 V3 E2 E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (cons E1 E2) V @
V1 : vars E1 V2 *
V2 : vars E2 V3 *
V3 : V2 ++ V3 = V
H1 : is_expr E1
H2 : is_expr E2
H3 : is_list is_string V2
H4 : is_list is_string V3
============================
 is_list is_string V

 < apply append_list_string_is to _ _ V3.

Subgoal 1.21:

Variables: V V2 V3 E2 E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (cons E1 E2) V @
V1 : vars E1 V2 *
V2 : vars E2 V3 *
V3 : V2 ++ V3 = V
H1 : is_expr E1
H2 : is_expr E2
H3 : is_list is_string V2
H4 : is_list is_string V3
H5 : is_list is_string V
============================
 is_list is_string V

 < search.

Subgoal 1.22:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
IsE : is_expr (head E1)
V : vars (head E1) V @
V1 : vars E1 V *
============================
 is_list is_string V

 < case IsE.

Subgoal 1.22:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (head E1) V @
V1 : vars E1 V *
H1 : is_expr E1
============================
 is_list is_string V

 < apply IH to _ V1.

Subgoal 1.22:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (head E1) V @
V1 : vars E1 V *
H1 : is_expr E1
H2 : is_list is_string V
============================
 is_list is_string V

 < search.

Subgoal 1.23:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
IsE : is_expr (tail E1)
V : vars (tail E1) V @
V1 : vars E1 V *
============================
 is_list is_string V

 < case IsE.

Subgoal 1.23:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (tail E1) V @
V1 : vars E1 V *
H1 : is_expr E1
============================
 is_list is_string V

 < apply IH to _ V1.

Subgoal 1.23:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (tail E1) V @
V1 : vars E1 V *
H1 : is_expr E1
H2 : is_list is_string V
============================
 is_list is_string V

 < search.

Subgoal 1.24:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
IsE : is_expr (null E1)
V : vars (null E1) V @
V1 : vars E1 V *
============================
 is_list is_string V

 < case IsE.

Subgoal 1.24:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (null E1) V @
V1 : vars E1 V *
H1 : is_expr E1
============================
 is_list is_string V

 < apply IH to _ V1.

Subgoal 1.24:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (null E1) V @
V1 : vars E1 V *
H1 : is_expr E1
H2 : is_list is_string V
============================
 is_list is_string V

 < search.

Proof completed.

 < Prove matchEval:host:vars_exist,
         matchEval:host:varsArgs_exist,
         matchEval:host:varsRecFields_exist.

Subgoal 1.20:

Variables: Typ
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (nil Typ) @
IsE1 : is_typ Typ
============================
 exists V, vars (nil Typ) V

 < search.

Subgoal 1.21:

Variables: Expr Expr1
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (cons Expr1 Expr) @
IsE1 : is_expr Expr1 *
IsE2 : is_expr Expr *
============================
 exists V, vars (cons Expr1 Expr) V

 < V1: apply IH to IsE1.

Subgoal 1.21:

Variables: Expr Expr1 V
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (cons Expr1 Expr) @
IsE1 : is_expr Expr1 *
IsE2 : is_expr Expr *
V1 : vars Expr1 V
============================
 exists V, vars (cons Expr1 Expr) V

 < V2: apply IH to IsE2.

Subgoal 1.21:

Variables: Expr Expr1 V V1
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (cons Expr1 Expr) @
IsE1 : is_expr Expr1 *
IsE2 : is_expr Expr *
V1 : vars Expr1 V
V2 : vars Expr V1
============================
 exists V, vars (cons Expr1 Expr) V

 < IsV1: apply vars_is to _ V1.

Subgoal 1.21:

Variables: Expr Expr1 V V1
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (cons Expr1 Expr) @
IsE1 : is_expr Expr1 *
IsE2 : is_expr Expr *
V1 : vars Expr1 V
V2 : vars Expr V1
IsV1 : is_list is_string V
============================
 exists V, vars (cons Expr1 Expr) V

 < IsV2: apply vars_is to _ V2.

Subgoal 1.21:

Variables: Expr Expr1 V V1
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (cons Expr1 Expr) @
IsE1 : is_expr Expr1 *
IsE2 : is_expr Expr *
V1 : vars Expr1 V
V2 : vars Expr V1
IsV1 : is_list is_string V
IsV2 : is_list is_string V1
============================
 exists V, vars (cons Expr1 Expr) V

 < apply append_list_string_total to IsV1 IsV2.

Subgoal 1.21:

Variables: Expr Expr1 V V1 L3
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (cons Expr1 Expr) @
IsE1 : is_expr Expr1 *
IsE2 : is_expr Expr *
V1 : vars Expr1 V
V2 : vars Expr V1
IsV1 : is_list is_string V
IsV2 : is_list is_string V1
H1 : V ++ V1 = L3
============================
 exists V, vars (cons Expr1 Expr) V

 < search.

Subgoal 1.22:

Variables: Expr
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (head Expr) @
IsE1 : is_expr Expr *
============================
 exists V, vars (head Expr) V

 < apply IH to IsE1.

Subgoal 1.22:

Variables: Expr V
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (head Expr) @
IsE1 : is_expr Expr *
H1 : vars Expr V
============================
 exists V, vars (head Expr) V

 < search.

Subgoal 1.23:

Variables: Expr
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (tail Expr) @
IsE1 : is_expr Expr *
============================
 exists V, vars (tail Expr) V

 < apply IH to IsE1.

Subgoal 1.23:

Variables: Expr V
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (tail Expr) @
IsE1 : is_expr Expr *
H1 : vars Expr V
============================
 exists V, vars (tail Expr) V

 < search.

Subgoal 1.24:

Variables: Expr
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (null Expr) @
IsE1 : is_expr Expr *
============================
 exists V, vars (null Expr) V

 < apply IH to IsE1.

Subgoal 1.24:

Variables: Expr V
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (null Expr) @
IsE1 : is_expr Expr *
H1 : vars Expr V
============================
 exists V, vars (null Expr) V

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_expr_vars.

Subgoal 1:

Variables: V V_P X Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
V : vars (nil Ty) V
V_P : vars (recBuild (consRecFieldExprs "null" true nilRecFieldExprs)) V_P
Mem : mem X V
============================
 mem X V_P

 < case V.

Subgoal 1:

Variables: V_P X Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
V_P : vars (recBuild (consRecFieldExprs "null" true nilRecFieldExprs)) V_P
Mem : mem X []
============================
 mem X V_P

 < case Mem.

Subgoal 2:

Variables: V V_P X E2 E1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsE : is_expr (cons E1 E2)
V : vars (cons E1 E2) V
V_P : vars (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V_P
Mem : mem X V
============================
 mem X V_P

 < case IsE.

Subgoal 2:

Variables: V V_P X E2 E1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
V : vars (cons E1 E2) V
V_P : vars (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V_P
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
============================
 mem X V_P

 < V: case V.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
V_P : vars (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V_P
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
============================
 mem X V_P

 < V_P: case V_P.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : varsRecFields (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs))) V_P
============================
 mem X V_P

 < V_P: case V_P.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3 VE VRest
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : vars false VE
V_P1 : varsRecFields (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)) VRest
V_P2 : VE ++ VRest = V_P
============================
 mem X V_P

 < V_P: case V_P1.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3 VE VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P3 : varsRecFields (consRecFieldExprs "tail" E2 nilRecFieldExprs) VRest1
V_P4 : VE1 ++ VRest1 = VRest
============================
 mem X V_P

 < V_P: case V_P3.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3 VE VRest VE1 VRest1 VE2 VRest2
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VE2
V_P5 : varsRecFields nilRecFieldExprs VRest2
V_P6 : VE2 ++ VRest2 = VRest1
============================
 mem X V_P

 < case V_P5.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3 VE VRest VE1 VRest1 VE2
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VE2
V_P6 : VE2 ++ [] = VRest1
============================
 mem X V_P

 < apply append_nil_right to V_P6.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3 VE VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VRest1
V_P6 : VRest1 ++ [] = VRest1
============================
 mem X V_P

 < clear V_P6.

Subgoal 2:

Variables: V V_P X E2 E1 V2 V3 VE VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 V2
V1 : vars E2 V3
V2 : V2 ++ V3 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VRest1
============================
 mem X V_P

 < apply vars_unique to _ V V_P1.

Subgoal 2:

Variables: V V_P X E2 E1 V3 VE VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 VE1
V1 : vars E2 V3
V2 : VE1 ++ V3 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VRest1
============================
 mem X V_P

 < apply vars_unique to _ V1 V_P3.

Subgoal 2:

Variables: V V_P X E2 E1 VE VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 VE1
V1 : vars E2 VRest1
V2 : VE1 ++ VRest1 = V
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VRest1
============================
 mem X V_P

 < apply append_unique to V2 V_P4.

Subgoal 2:

Variables: V_P X E2 E1 VE VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X VRest
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 VE1
V1 : vars E2 VRest1
V2 : VE1 ++ VRest1 = VRest
V_P : vars false VE
V_P2 : VE ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VRest1
============================
 mem X V_P

 < case V_P.

Subgoal 2:

Variables: V_P X E2 E1 VRest VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X VRest
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 VE1
V1 : vars E2 VRest1
V2 : VE1 ++ VRest1 = VRest
V_P2 : [] ++ VRest = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = VRest
V_P3 : vars E2 VRest1
============================
 mem X V_P

 < case V_P2.

Subgoal 2:

Variables: V_P X E2 E1 VE1 VRest1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
Mem : mem X V_P
H1 : is_expr E1
H2 : is_expr E2
V : vars E1 VE1
V1 : vars E2 VRest1
V2 : VE1 ++ VRest1 = V_P
V_P1 : vars E1 VE1
V_P4 : VE1 ++ VRest1 = V_P
V_P3 : vars E2 VRest1
============================
 mem X V_P

 < search.

Subgoal 3:

Variables: V V_P X E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsE : is_expr (null E1)
V : vars (null E1) V
V_P : vars (recFieldAccess E1 "null") V_P
Mem : mem X V
============================
 mem X V_P

 < V: case V.

Subgoal 3:

Variables: V V_P X E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsE : is_expr (null E1)
V_P : vars (recFieldAccess E1 "null") V_P
Mem : mem X V
V : vars E1 V
============================
 mem X V_P

 < V_P: case V_P.

Subgoal 3:

Variables: V V_P X E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsE : is_expr (null E1)
Mem : mem X V
V : vars E1 V
V_P : vars E1 V_P
============================
 mem X V_P

 < case IsE.

Subgoal 3:

Variables: V V_P X E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
Mem : mem X V
V : vars E1 V
V_P : vars E1 V_P
H1 : is_expr E1
============================
 mem X V_P

 < apply vars_unique to _ V V_P.

Subgoal 3:

Variables: V_P X E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
Mem : mem X V_P
V : vars E1 V_P
V_P : vars E1 V_P
H1 : is_expr E1
============================
 mem X V_P

 < search.

Subgoal 4:

Variables: V V_P X E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
IsE : is_expr (head E1)
V : vars (head E1) V
V_P : vars (recFieldAccess E1 "head") V_P
Mem : mem X V
============================
 mem X V_P

 < V: case V.

Subgoal 4:

Variables: V V_P X E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
IsE : is_expr (head E1)
V_P : vars (recFieldAccess E1 "head") V_P
Mem : mem X V
V : vars E1 V
============================
 mem X V_P

 < V_P: case V_P.

Subgoal 4:

Variables: V V_P X E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
IsE : is_expr (head E1)
Mem : mem X V
V : vars E1 V
V_P : vars E1 V_P
============================
 mem X V_P

 < case IsE.

Subgoal 4:

Variables: V V_P X E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
Mem : mem X V
V : vars E1 V
V_P : vars E1 V_P
H1 : is_expr E1
============================
 mem X V_P

 < apply vars_unique to _ V V_P.

Subgoal 4:

Variables: V_P X E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
Mem : mem X V_P
V : vars E1 V_P
V_P : vars E1 V_P
H1 : is_expr E1
============================
 mem X V_P

 < search.

Subgoal 5:

Variables: V V_P X E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
IsE : is_expr (tail E1)
V : vars (tail E1) V
V_P : vars (recFieldAccess E1 "tail") V_P
Mem : mem X V
============================
 mem X V_P

 < V: case V.

Subgoal 5:

Variables: V V_P X E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
IsE : is_expr (tail E1)
V_P : vars (recFieldAccess E1 "tail") V_P
Mem : mem X V
V : vars E1 V
============================
 mem X V_P

 < V_P: case V_P.

Subgoal 5:

Variables: V V_P X E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
IsE : is_expr (tail E1)
Mem : mem X V
V : vars E1 V
V_P : vars E1 V_P
============================
 mem X V_P

 < case IsE.

Subgoal 5:

Variables: V V_P X E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
Mem : mem X V
V : vars E1 V
V_P : vars E1 V_P
H1 : is_expr E1
============================
 mem X V_P

 < apply vars_unique to _ V V_P.

Subgoal 5:

Variables: V_P X E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
Mem : mem X V_P
V : vars E1 V_P
V_P : vars E1 V_P
H1 : is_expr E1
============================
 mem X V_P

 < search.

Proof completed.

 < Prove matchEval:host:typeOf_isTy.

Subgoal 1.22:

Variables: FT ET Ty1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsE : is_expr (nil Ty1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (nil Ty1) (listTy Ty1) @
============================
 is_typ (listTy Ty1)

 < case IsE.

Subgoal 1.22:

Variables: FT ET Ty1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (nil Ty1) (listTy Ty1) @
H1 : is_typ Ty1
============================
 is_typ (listTy Ty1)

 < search.

Subgoal 1.23:

Variables: FT ET Ty1 E2 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsE : is_expr (cons E1 E2)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (cons E1 E2) (listTy Ty1) @
Ty1 : typeOf FT ET E1 Ty1 *
Ty2 : typeOf FT ET E2 (listTy Ty1) *
============================
 is_typ (listTy Ty1)

 < case IsE.

Subgoal 1.23:

Variables: FT ET Ty1 E2 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (cons E1 E2) (listTy Ty1) @
Ty1 : typeOf FT ET E1 Ty1 *
Ty2 : typeOf FT ET E2 (listTy Ty1) *
H1 : is_expr E1
H2 : is_expr E2
============================
 is_typ (listTy Ty1)

 < apply IH to _ _ _ Ty1.

Subgoal 1.23:

Variables: FT ET Ty1 E2 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (cons E1 E2) (listTy Ty1) @
Ty1 : typeOf FT ET E1 Ty1 *
Ty2 : typeOf FT ET E2 (listTy Ty1) *
H1 : is_expr E1
H2 : is_expr E2
H3 : is_typ Ty1
============================
 is_typ (listTy Ty1)

 < search.

Subgoal 1.24:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsE : is_expr (head E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (head E1) Ty @
Ty1 : typeOf FT ET E1 (listTy Ty) *
============================
 is_typ Ty

 < case IsE.

Subgoal 1.24:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (head E1) Ty @
Ty1 : typeOf FT ET E1 (listTy Ty) *
H1 : is_expr E1
============================
 is_typ Ty

 < Is: apply IH to _ _ _ Ty1.

Subgoal 1.24:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (head E1) Ty @
Ty1 : typeOf FT ET E1 (listTy Ty) *
H1 : is_expr E1
Is : is_typ (listTy Ty)
============================
 is_typ Ty

 < case Is.

Subgoal 1.24:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (head E1) Ty @
Ty1 : typeOf FT ET E1 (listTy Ty) *
H1 : is_expr E1
H2 : is_typ Ty
============================
 is_typ Ty

 < search.

Subgoal 1.25:

Variables: FT ET Ty1 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsE : is_expr (tail E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (tail E1) (listTy Ty1) @
Ty1 : typeOf FT ET E1 (listTy Ty1) *
============================
 is_typ (listTy Ty1)

 < case IsE.

Subgoal 1.25:

Variables: FT ET Ty1 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (tail E1) (listTy Ty1) @
Ty1 : typeOf FT ET E1 (listTy Ty1) *
H1 : is_expr E1
============================
 is_typ (listTy Ty1)

 < apply IH to _ _ _ Ty1.

Subgoal 1.25:

Variables: FT ET Ty1 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (tail E1) (listTy Ty1) @
Ty1 : typeOf FT ET E1 (listTy Ty1) *
H1 : is_expr E1
H2 : is_typ (listTy Ty1)
============================
 is_typ (listTy Ty1)

 < search.

Subgoal 1.26:

Variables: FT ET Ty1 E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsE : is_expr (null E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (null E1) boolTy @
Ty1 : typeOf FT ET E1 (listTy Ty1) *
============================
 is_typ boolTy

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_isCtx.

Subgoal 12:

Variables: FT ET' Ty E I L
IH : forall S FT ET ET',
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> stmtOK FT ET S ET' * ->
       is_list (is_list (is_pair is_string is_typ)) ET'
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
Ty : stmtOK FT ET' (listUpdate L I E) ET' @
Ty1 : lookupScopes L ET' (listTy Ty)
Ty2 : typeOf FT ET' I intTy
Ty3 : typeOf FT ET' E Ty
============================
 is_list (is_list (is_pair is_string is_typ)) ET'

 < search.

Subgoal 13:

Variables: FT ET' Ty TC1 Body L X
IH : forall S FT ET ET',
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> stmtOK FT ET S ET' * ->
       is_list (is_list (is_pair is_string is_typ)) ET'
IsS : is_stmt (listForeach X L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
Ty : stmtOK FT ET' (listForeach X L Body) ET' @
Ty1 : typeOf FT ET' L (listTy Ty)
Ty2 : stmtOK FT ([(X, Ty)]::ET') Body TC1 *
============================
 is_list (is_list (is_pair is_string is_typ)) ET'

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_keep_scopes.

Subgoal 12:

Variables: FT ET' N Ty E I L
IH : forall FT ET S ET' N,
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> stmtOK FT ET S ET' * ->
       length ET N -> length ET' N
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
Ty : stmtOK FT ET' (listUpdate L I E) ET' @
L : length ET' N
Ty1 : lookupScopes L ET' (listTy Ty)
Ty2 : typeOf FT ET' I intTy
Ty3 : typeOf FT ET' E Ty
============================
 length ET' N

 < search.

Subgoal 13:

Variables: FT ET' N Ty TC1 Body L X
IH : forall FT ET S ET' N,
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> stmtOK FT ET S ET' * ->
       length ET N -> length ET' N
IsS : is_stmt (listForeach X L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
Ty : stmtOK FT ET' (listForeach X L Body) ET' @
L : length ET' N
Ty1 : typeOf FT ET' L (listTy Ty)
Ty2 : stmtOK FT ([(X, Ty)]::ET') Body TC1 *
============================
 length ET' N

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_older_scopes_same.

Subgoal 12:

Variables: FT ET Scope Ty E I L
IH : forall FT ET S ET' Scope,
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) (Scope::ET) -> stmtOK FT (Scope::ET) S ET' * ->
       exists Scope', ET' = Scope'::ET
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (listUpdate L I E) (Scope::ET) @
Ty1 : lookupScopes L (Scope::ET) (listTy Ty)
Ty2 : typeOf FT (Scope::ET) I intTy
Ty3 : typeOf FT (Scope::ET) E Ty
============================
 exists Scope', Scope::ET = Scope'::ET

 < search.

Subgoal 13:

Variables: FT ET Scope Ty TC1 Body L X
IH : forall FT ET S ET' Scope,
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) (Scope::ET) -> stmtOK FT (Scope::ET) S ET' * ->
       exists Scope', ET' = Scope'::ET
IsS : is_stmt (listForeach X L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (listForeach X L Body) (Scope::ET) @
Ty1 : typeOf FT (Scope::ET) L (listTy Ty)
Ty2 : stmtOK FT ([(X, Ty)]::(Scope::ET)) Body TC1 *
============================
 exists Scope', Scope::ET = Scope'::ET

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_first_scope_lookup_same.

Subgoal 12:

Variables: FT ET Scope' X Ty Ty1 E I L
IH : forall FT ET S Scope Scope' X Ty,
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) (Scope'::ET)
Ty : stmtOK FT (Scope'::ET) (listUpdate L I E) (Scope'::ET) @
L : lookup Scope' X Ty
Ty1 : lookupScopes L (Scope'::ET) (listTy Ty1)
Ty2 : typeOf FT (Scope'::ET) I intTy
Ty3 : typeOf FT (Scope'::ET) E Ty1
============================
 lookup Scope' X Ty

 < search.

Subgoal 13:

Variables: FT ET Scope' X Ty Ty1 TC1 Body L X1
IH : forall FT ET S Scope Scope' X Ty,
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (listForeach X1 L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) (Scope'::ET)
Ty : stmtOK FT (Scope'::ET) (listForeach X1 L Body) (Scope'::ET) @
L : lookup Scope' X Ty
Ty1 : typeOf FT (Scope'::ET) L (listTy Ty1)
Ty2 : stmtOK FT ([(X1, Ty1)]::(Scope'::ET)) Body TC1 *
============================
 lookup Scope' X Ty

 < search.

Proof completed.

 < Prove matchEval:host:typeOf_unique.

Subgoal 1.22:

Variables: FT ET_A ET_B TyB Ty
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (nil Ty)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (nil Ty) (listTy Ty) @
TyB : typeOf FT ET_B (nil Ty) TyB
Lkp : lookup_all_scopes ET_A ET_B
============================
 listTy Ty = TyB

 < case TyB.

Subgoal 1.22:

Variables: FT ET_A ET_B Ty
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (nil Ty)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (nil Ty) (listTy Ty) @
Lkp : lookup_all_scopes ET_A ET_B
============================
 listTy Ty = listTy Ty

 < search.

Subgoal 1.23:

Variables: FT ET_A ET_B TyB Ty E2 E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (cons E1 E2)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (cons E1 E2) (listTy Ty) @
TyB : typeOf FT ET_B (cons E1 E2) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 Ty *
TyA2 : typeOf FT ET_A E2 (listTy Ty) *
============================
 listTy Ty = TyB

 < case IsE.

Subgoal 1.23:

Variables: FT ET_A ET_B TyB Ty E2 E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (cons E1 E2) (listTy Ty) @
TyB : typeOf FT ET_B (cons E1 E2) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 Ty *
TyA2 : typeOf FT ET_A E2 (listTy Ty) *
H1 : is_expr E1
H2 : is_expr E2
============================
 listTy Ty = TyB

 < TyB: case TyB.

Subgoal 1.23:

Variables: FT ET_A ET_B Ty E2 E1 Ty1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (cons E1 E2) (listTy Ty) @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 Ty *
TyA2 : typeOf FT ET_A E2 (listTy Ty) *
H1 : is_expr E1
H2 : is_expr E2
TyB : typeOf FT ET_B E1 Ty1
TyB1 : typeOf FT ET_B E2 (listTy Ty1)
============================
 listTy Ty = listTy Ty1

 < apply IH_E to _ _ _ _ TyA1 TyB _.

Subgoal 1.23:

Variables: FT ET_A ET_B E2 E1 Ty1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (cons E1 E2) (listTy Ty1) @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 Ty1 *
TyA2 : typeOf FT ET_A E2 (listTy Ty1) *
H1 : is_expr E1
H2 : is_expr E2
TyB : typeOf FT ET_B E1 Ty1
TyB1 : typeOf FT ET_B E2 (listTy Ty1)
============================
 listTy Ty1 = listTy Ty1

 < search.

Subgoal 1.24:

Variables: FT ET_A ET_B TyA TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (head E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (head E1) TyA @
TyB : typeOf FT ET_B (head E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy TyA) *
============================
 TyA = TyB

 < case IsE.

Subgoal 1.24:

Variables: FT ET_A ET_B TyA TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (head E1) TyA @
TyB : typeOf FT ET_B (head E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy TyA) *
H1 : is_expr E1
============================
 TyA = TyB

 < TyB: case TyB.

Subgoal 1.24:

Variables: FT ET_A ET_B TyA TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (head E1) TyA @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy TyA) *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 (listTy TyB)
============================
 TyA = TyB

 < apply IH_E to _ _ _ _ TyA1 TyB _.

Subgoal 1.24:

Variables: FT ET_A ET_B TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (head E1) TyB @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy TyB) *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 (listTy TyB)
============================
 TyB = TyB

 < search.

Subgoal 1.25:

Variables: FT ET_A ET_B TyB Ty E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (tail E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (tail E1) (listTy Ty) @
TyB : typeOf FT ET_B (tail E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty) *
============================
 listTy Ty = TyB

 < case IsE.

Subgoal 1.25:

Variables: FT ET_A ET_B TyB Ty E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (tail E1) (listTy Ty) @
TyB : typeOf FT ET_B (tail E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty) *
H1 : is_expr E1
============================
 listTy Ty = TyB

 < TyB: case TyB.

Subgoal 1.25:

Variables: FT ET_A ET_B Ty E1 Ty1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (tail E1) (listTy Ty) @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty) *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 (listTy Ty1)
============================
 listTy Ty = listTy Ty1

 < apply IH_E to _ _ _ _ TyA1 TyB _.

Subgoal 1.25:

Variables: FT ET_A ET_B E1 Ty1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (tail E1) (listTy Ty1) @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty1) *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 (listTy Ty1)
============================
 listTy Ty1 = listTy Ty1

 < search.

Subgoal 1.26:

Variables: FT ET_A ET_B TyB Ty E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (null E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (null E1) boolTy @
TyB : typeOf FT ET_B (null E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty) *
============================
 boolTy = TyB

 < case IsE.

Subgoal 1.26:

Variables: FT ET_A ET_B TyB Ty E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (null E1) boolTy @
TyB : typeOf FT ET_B (null E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty) *
H1 : is_expr E1
============================
 boolTy = TyB

 < TyB: case TyB.

Subgoal 1.26:

Variables: FT ET_A ET_B Ty E1 Ty1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (null E1) boolTy @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 (listTy Ty) *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 (listTy Ty1)
============================
 boolTy = boolTy

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_unique.

Subgoal 12:

Variables: FT ET_B ET_A' ET_B' Ty E I L
IH : forall FT ET_A ET_B S ET_A' ET_B',
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
       stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
       lookup_all_scopes ET_A' ET_B'
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A'
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : stmtOK FT ET_A' (listUpdate L I E) ET_A' @
TyB : stmtOK FT ET_B (listUpdate L I E) ET_B'
Lkp : lookup_all_scopes ET_A' ET_B
TyA1 : lookupScopes L ET_A' (listTy Ty)
TyA2 : typeOf FT ET_A' I intTy
TyA3 : typeOf FT ET_A' E Ty
============================
 lookup_all_scopes ET_A' ET_B'

 < case TyB.

Subgoal 12:

Variables: FT ET_A' ET_B' Ty E I L Ty1
IH : forall FT ET_A ET_B S ET_A' ET_B',
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
       stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
       lookup_all_scopes ET_A' ET_B'
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A'
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B'
TyA : stmtOK FT ET_A' (listUpdate L I E) ET_A' @
Lkp : lookup_all_scopes ET_A' ET_B'
TyA1 : lookupScopes L ET_A' (listTy Ty)
TyA2 : typeOf FT ET_A' I intTy
TyA3 : typeOf FT ET_A' E Ty
H1 : lookupScopes L ET_B' (listTy Ty1)
H2 : typeOf FT ET_B' I intTy
H3 : typeOf FT ET_B' E Ty1
============================
 lookup_all_scopes ET_A' ET_B'

 < search.

Subgoal 13:

Variables: FT ET_B ET_A' ET_B' Ty TC1 Body L X
IH : forall FT ET_A ET_B S ET_A' ET_B',
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
       stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
       lookup_all_scopes ET_A' ET_B'
IsS : is_stmt (listForeach X L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A'
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : stmtOK FT ET_A' (listForeach X L Body) ET_A' @
TyB : stmtOK FT ET_B (listForeach X L Body) ET_B'
Lkp : lookup_all_scopes ET_A' ET_B
TyA1 : typeOf FT ET_A' L (listTy Ty)
TyA2 : stmtOK FT ([(X, Ty)]::ET_A') Body TC1 *
============================
 lookup_all_scopes ET_A' ET_B'

 < TyB: case TyB.

Subgoal 13:

Variables: FT ET_A' ET_B' Ty TC1 Body L X Ty1 TC2
IH : forall FT ET_A ET_B S ET_A' ET_B',
       is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
       stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
       lookup_all_scopes ET_A' ET_B'
IsS : is_stmt (listForeach X L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A'
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B'
TyA : stmtOK FT ET_A' (listForeach X L Body) ET_A' @
Lkp : lookup_all_scopes ET_A' ET_B'
TyA1 : typeOf FT ET_A' L (listTy Ty)
TyA2 : stmtOK FT ([(X, Ty)]::ET_A') Body TC1 *
TyB : typeOf FT ET_B' L (listTy Ty1)
TyB1 : stmtOK FT ([(X, Ty1)]::ET_B') Body TC2
============================
 lookup_all_scopes ET_A' ET_B'

 < search.

Proof completed.

 < Prove matchEval:host:paramTy_is.

Proof completed.

 < Prove matchEval:host:getFunInfo_is.

Proof completed.

 < Prove matchEval:host:paramTy_exists.

Proof completed.

 < Prove matchEval:host:getFunInfo_exists.

Proof completed.

 < Theorem updateListIndex_is :
     forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out -> is_value Out.

============================
 forall L I V Out,
   is_value L -> is_value V -> updateListIndex L I V Out -> is_value Out

 < induction on 3.

IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
============================
 forall L I V Out,
   is_value L -> is_value V -> updateListIndex L I V Out @ -> is_value Out

 < intros IsL IsV ULI.

Variables: L I V Out
IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
IsL : is_value L
IsV : is_value V
ULI : updateListIndex L I V Out @
============================
 is_value Out

 < ULI: case ULI.

Subgoal 1:

Variables: V Tl VOld
IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
IsL : is_value (consVal VOld Tl)
IsV : is_value V
============================
 is_value (consVal V Tl)

 < case IsL.

Subgoal 1:

Variables: V Tl VOld
IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
IsV : is_value V
H1 : is_value VOld
H2 : is_value Tl
============================
 is_value (consVal V Tl)

 < search.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
IsL : is_value (consVal X Tl)
IsV : is_value V
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
============================
 is_value (consVal X TlNew)

 < case IsL.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
IsV : is_value V
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
H1 : is_value X
H2 : is_value Tl
============================
 is_value (consVal X TlNew)

 < apply IH to _ _ ULI1.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out,
       is_value L -> is_value V -> updateListIndex L I V Out * -> is_value Out
IsV : is_value V
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
H1 : is_value X
H2 : is_value Tl
H3 : is_value TlNew
============================
 is_value (consVal X TlNew)

 < search.

Proof completed.

 < Prove matchEval:host:matchInt_is.

Proof completed.

 < Prove matchEval:host:matchString_is.

Proof completed.

 < Prove matchEval:host:matchRec_is.

Subgoal 2:

IH : forall V Fs,
       is_value V -> matchRec V Fs * -> is_list (is_pair is_string is_value) Fs
IsV : is_value nilVal
MR : matchRec nilVal [("null", trueVal)] @
============================
 is_list (is_pair is_string is_value) [("null", trueVal)]

 < search 10.

Subgoal 3:

Variables: V2 V1
IH : forall V Fs,
       is_value V -> matchRec V Fs * -> is_list (is_pair is_string is_value) Fs
IsV : is_value (consVal V1 V2)
MR : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
============================
 is_list (is_pair is_string is_value) [("null", falseVal), ("head", V1), ("tail", V2)]

 < case IsV.

Subgoal 3:

Variables: V2 V1
IH : forall V Fs,
       is_value V -> matchRec V Fs * -> is_list (is_pair is_string is_value) Fs
MR : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
H1 : is_value V1
H2 : is_value V2
============================
 is_list (is_pair is_string is_value) [("null", falseVal), ("head", V1), ("tail", V2)]

 < search 20.

Proof completed.

 < Prove matchEval:host:evalExpr_isValue,
         matchEval:host:evalStmt_isCtx,
         matchEval:host:evalArgs_isValue,
         matchEval:host:evalRecFields_isValue
   with
      iterateList_isCtx : forall FE EE V X Body EE' O,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsEE : is_list (is_list (is_pair is_string is_value)) EE ->
         IL : iterateList FE EE V X Body EE' O ->
         is_list (is_list (is_pair is_string is_value)) EE'
      on IL as IH_IL.

Subgoal 1.32:

Variables: FE EE Ty
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (nil Ty) nilVal [] @
============================
 is_value nilVal

 < case IsE.

Subgoal 1.32:

Variables: FE EE Ty
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (nil Ty) nilVal [] @
H1 : is_typ Ty
============================
 is_value nilVal

 < search 10.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
============================
 is_value (consVal V1 V2)

 < case IsE.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 is_value (consVal V1 V2)

 < apply IH_V_E to _ _ _ Ev1.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : is_value V1
============================
 is_value (consVal V1 V2)

 < apply IH_V_E to _ _ _ Ev2.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : is_value V1
H4 : is_value V2
============================
 is_value (consVal V1 V2)

 < search 20.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
============================
 is_value V

 < case IsE.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
============================
 is_value V

 < Is: apply IH_V_E to _ _ _ Ev1.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
Is : is_value (consVal V Tl)
============================
 is_value V

 < case Is.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
H2 : is_value V
H3 : is_value Tl
============================
 is_value V

 < search.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
============================
 is_value V

 < case IsE.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
============================
 is_value V

 < Is: apply IH_V_E to _ _ _ Ev1.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
Is : is_value (consVal Hd V)
============================
 is_value V

 < case Is.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
H2 : is_value Hd
H3 : is_value V
============================
 is_value V

 < search.

Subgoal 1.36:

Variables: FE EE O E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
============================
 is_value trueVal

 < search.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
============================
 is_value falseVal

 < search.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < case IsS.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply lookupScopes_is to _ Ev1.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_value LV
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply IH_V_E to _ _ _ Ev2.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_value LV
H5 : is_value VI
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply IH_V_E to _ _ _ Ev4.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_value LV
H5 : is_value VI
H6 : is_value V
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply updateListIndex_is to _ _ Ev5.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_value LV
H5 : is_value VI
H6 : is_value V
H7 : is_value LV2
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply replaceScopes_is to _ _ Ev6.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_value LV
H5 : is_value VI
H6 : is_value V
H7 : is_value LV2
H8 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < search.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < case IsS.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply IH_V_E to _ _ _ Ev1.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_value LV
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply IH_IL to _ _ _ _ _ Ev2.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_value LV
H5 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < search.

Subgoal 5.1:

Variables: FE X Body EE'
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
IL : iterateList FE EE' nilVal X Body EE' [] @
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < search.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < case IsV.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < IsEE3+: apply IH_C_S to _ _ _ IL1.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE3+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < case IsEE3+.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < apply IH_IL to _ _ _ _ _ IL2.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list (is_list (is_pair is_string is_value)) EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE3
H5 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 is_list (is_list (is_pair is_string is_value)) EE'

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_isOutput,
         matchEval:host:evalStmt_isOutput,
         matchEval:host:evalArgs_isOutput,
         matchEval:host:evalRecFields_isOutput
   with
      iterateList_isOutput : forall FE EE V X Body EE' O,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsEE : is_list (is_list (is_pair is_string is_value)) EE ->
         IL : iterateList FE EE V X Body EE' O ->
         is_list is_value O
      on IL as IH_IL.

Subgoal 1.32:

Variables: FE EE Ty
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (nil Ty) nilVal [] @
============================
 is_list is_value []

 < search.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
============================
 is_list is_value O

 < case IsE.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : is_list is_value O2
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev2.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : is_list is_value O2
H4 : is_list is_value O3
============================
 is_list is_value O

 < apply append_values_is to _ _ Ev3.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : is_list is_value O2
H4 : is_list is_value O3
H5 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
============================
 is_list is_value O

 < case IsE.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
H2 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
============================
 is_list is_value O

 < case IsE.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
H2 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 1.36:

Variables: FE EE O E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
============================
 is_list is_value O

 < case IsE.

Subgoal 1.36:

Variables: FE EE O E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
H1 : is_expr E1
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.36:

Variables: FE EE O E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
H1 : is_expr E1
H2 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
============================
 is_list is_value O

 < case IsE.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
H1 : is_expr E1
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
H1 : is_expr E1
H2 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
============================
 is_list is_value O

 < case IsS.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev2.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_list is_value O2
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev4.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_list is_value O2
H5 : is_list is_value O3
============================
 is_list is_value O

 < apply append_values_is to _ _ Ev7.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : is_list is_value O2
H5 : is_list is_value O3
H6 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 is_list is_value O

 < case IsS.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_list is_value O2
============================
 is_list is_value O

 < apply evalExpr_isValue to _ _ _ Ev1.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_list is_value O2
H5 : is_value LV
============================
 is_list is_value O

 < apply IH_IL to _ _ _ _ _ Ev2.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_list is_value O2
H5 : is_value LV
H6 : is_list is_value O3
============================
 is_list is_value O

 < apply append_values_is to _ _ Ev3.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_list is_value O2
H5 : is_value LV
H6 : is_list is_value O3
H7 : is_list is_value O
============================
 is_list is_value O

 < search.

Subgoal 5.1:

Variables: FE X Body EE'
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
IL : iterateList FE EE' nilVal X Body EE' [] @
============================
 is_list is_value []

 < search.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 is_list is_value O

 < case IsV.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 is_list is_value O

 < apply IH_S to _ _ _ IL1.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list is_value O2
============================
 is_list is_value O

 < IsEE3+: apply evalStmt_isCtx to _ _ _ IL1.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list is_value O2
IsEE3+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 is_list is_value O

 < case IsEE3+.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list is_value O2
H4 : is_list (is_pair is_string is_value) Scope
H5 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 is_list is_value O

 < apply IH_IL to _ _ _ _ _ IL2.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list is_value O2
H4 : is_list (is_pair is_string is_value) Scope
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : is_list is_value O3
============================
 is_list is_value O

 < apply append_values_is to _ _ IL3.

Subgoal 5.2:

Variables: FE EE X Body EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IH_IL : forall FE EE V X Body EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          is_list is_value O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list is_value O2
H4 : is_list (is_pair is_string is_value) Scope
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : is_list is_value O3
H7 : is_list is_value O
============================
 is_list is_value O

 < search.

Proof completed.

 < Prove matchEval:host:paramName_is.

Proof completed.

 < Prove matchEval:host:getFunEvalInfo_is.

Proof completed.

 < Prove matchEval:host:evalProgram_isOutput.

Proof completed.

 < Prove matchEval:host:evalStmt_names_same
   with
      iterateList_names_same : forall V X Body FE EE EE' O,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsEE : is_list (is_list (is_pair is_string is_value)) EE ->
         IL : iterateList FE EE V X Body EE' O ->
         names_same EE EE'
      on IL as IH_IL.

Subgoal 1.15:

Variables: FE Scope EE EE' O LV VI O2 N V O3 LV2 E I L
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listUpdate L I E) EE' O @
Ev1 : lookupScopes L (Scope::EE) LV
Ev2 : evalExpr FE (Scope::EE) I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE (Scope::EE) E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 (Scope::EE) EE'
Ev7 : O2 ++ O3 = O
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < case IsS.

Subgoal 1.15:

Variables: FE Scope EE EE' O LV VI O2 N V O3 LV2 E I L
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listUpdate L I E) EE' O @
Ev1 : lookupScopes L (Scope::EE) LV
Ev2 : evalExpr FE (Scope::EE) I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE (Scope::EE) E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 (Scope::EE) EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < NS: apply replaceScopes_names_same to _ Ev6.

Subgoal 1.15:

Variables: FE Scope EE EE' O LV VI O2 N V O3 LV2 E I L
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listUpdate L I E) EE' O @
Ev1 : lookupScopes L (Scope::EE) LV
Ev2 : evalExpr FE (Scope::EE) I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE (Scope::EE) E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 (Scope::EE) EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
NS : names_same (Scope::EE) EE'
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < case NS.

Subgoal 1.15:

Variables: FE Scope EE O LV VI O2 N V O3 LV2 E I L BRest B
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listUpdate L I E) (B::BRest) O @
Ev1 : lookupScopes L (Scope::EE) LV
Ev2 : evalExpr FE (Scope::EE) I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE (Scope::EE) E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 (Scope::EE) (B::BRest)
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
============================
 exists Scope' EE'', B::BRest = Scope'::EE'' /\ names_same EE EE''

 < search.

Subgoal 1.16:

Variables: FE Scope EE EE' O LV O2 O3 Body L X
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listForeach X L Body) EE' O @
Ev1 : evalExpr FE (Scope::EE) L LV O2 *
Ev2 : iterateList FE (Scope::EE) LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < case IsS.

Subgoal 1.16:

Variables: FE Scope EE EE' O LV O2 O3 Body L X
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listForeach X L Body) EE' O @
Ev1 : evalExpr FE (Scope::EE) L LV O2 *
Ev2 : iterateList FE (Scope::EE) LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < apply evalExpr_isValue to _ _ _ Ev1.

Subgoal 1.16:

Variables: FE Scope EE EE' O LV O2 O3 Body L X
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listForeach X L Body) EE' O @
Ev1 : evalExpr FE (Scope::EE) L LV O2 *
Ev2 : iterateList FE (Scope::EE) LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_value LV
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < NS: apply IH_IL to _ _ _ _ _ Ev2.

Subgoal 1.16:

Variables: FE Scope EE EE' O LV O2 O3 Body L X
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listForeach X L Body) EE' O @
Ev1 : evalExpr FE (Scope::EE) L LV O2 *
Ev2 : iterateList FE (Scope::EE) LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_value LV
NS : names_same (Scope::EE) EE'
============================
 exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''

 < case NS.

Subgoal 1.16:

Variables: FE Scope EE O LV O2 O3 Body L X BRest B
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (listForeach X L Body) (B::BRest) O @
Ev1 : evalExpr FE (Scope::EE) L LV O2 *
Ev2 : iterateList FE (Scope::EE) LV X Body (B::BRest) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : is_value LV
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
============================
 exists Scope' EE'', B::BRest = Scope'::EE'' /\ names_same EE EE''

 < search.

Subgoal 2.1:

Variables: X Body FE EE'
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
IL : iterateList FE EE' nilVal X Body EE' [] @
============================
 names_same EE' EE'

 < backchain names_same_reflexive.

Subgoal 2.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 names_same EE EE'

 < case IsV.

Subgoal 2.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 names_same EE EE'

 < IsEE3+: apply evalStmt_isCtx to _ _ _ IL1.

Subgoal 2.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE3+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 names_same EE EE'

 < case IsEE3+.

Subgoal 2.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 names_same EE EE'

 < NS1: apply IH_S to _ _ _ IL1.

Subgoal 2.2:

Variables: X Body FE EE EE' O O2 O3 Tl Hd Scope' EE''
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list (is_pair is_string is_value) Scope'
H4 : is_list (is_list (is_pair is_string is_value)) EE''
NS1 : names_same EE EE''
============================
 names_same EE EE'

 < NS2: apply IH_IL to _ _ _ _ _ IL2.

Subgoal 2.2:

Variables: X Body FE EE EE' O O2 O3 Tl Hd Scope' EE''
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list (is_pair is_string is_value) Scope'
H4 : is_list (is_list (is_pair is_string is_value)) EE''
NS1 : names_same EE EE''
NS2 : names_same EE'' EE'
============================
 names_same EE EE'

 < apply names_same_transitive to NS1 NS2.

Subgoal 2.2:

Variables: X Body FE EE EE' O O2 O3 Tl Hd Scope' EE''
IH_S : forall S FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          names_same EE EE'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : is_list (is_pair is_string is_value) Scope'
H4 : is_list (is_list (is_pair is_string is_value)) EE''
NS1 : names_same EE EE''
NS2 : names_same EE'' EE'
H5 : names_same EE EE'
============================
 names_same EE EE'

 < search.

Proof completed.

 < Theorem updateListIndex_geq_0 :
     forall L I V Out, is_integer I -> updateListIndex L I V Out -> I >= 0.

============================
 forall L I V Out, is_integer I -> updateListIndex L I V Out -> I >= 0

 < induction on 2.

IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
============================
 forall L I V Out, is_integer I -> updateListIndex L I V Out @ -> I >= 0

 < intros IsI ULI.

Variables: L I V Out
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer I
ULI : updateListIndex L I V Out @
============================
 I >= 0

 < ULI: case ULI.

Subgoal 1:

Variables: V Tl VOld
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer 0
============================
 0 >= 0

 < search.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
============================
 I >= 0

 < apply minus_integer_is_integer to _ _ ULI.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
H1 : is_integer I1
============================
 I >= 0

 < G: apply IH to _ ULI1.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
H1 : is_integer I1
G : I1 >= 0
============================
 I >= 0

 < P: apply minus_plus_same_integer to _ _ ULI.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
H1 : is_integer I1
G : I1 >= 0
P : I1 + 1 = I
============================
 I >= 0

 < apply greatereq_integer__add_positive to _ _ P.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V Out, is_integer I -> updateListIndex L I V Out * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
H1 : is_integer I1
G : I1 >= 0
P : I1 + 1 = I
H2 : I >= 0
============================
 I >= 0

 < search.

Proof completed.

 < Theorem updateListIndex_unique :
     forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA -> updateListIndex L I V OutB ->
       OutA = OutB.

============================
 forall L I V OutA OutB,
   is_value L -> is_value V -> updateListIndex L I V OutA -> updateListIndex L I V OutB ->
   OutA = OutB

 < induction on 3.

IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
============================
 forall L I V OutA OutB,
   is_value L -> is_value V -> updateListIndex L I V OutA @ -> updateListIndex L I V OutB ->
   OutA = OutB

 < intros IsL IsV ULIA ULIB.

Variables: L I V OutA OutB
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value L
IsV : is_value V
ULIA : updateListIndex L I V OutA @
ULIB : updateListIndex L I V OutB
============================
 OutA = OutB

 < ULIA: case ULIA.

Subgoal 1:

Variables: V OutB Tl VOld
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal VOld Tl)
IsV : is_value V
ULIB : updateListIndex (consVal VOld Tl) 0 V OutB
============================
 consVal V Tl = OutB

 < ULIB: case ULIB.

Subgoal 1.1:

Variables: V Tl VOld
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal VOld Tl)
IsV : is_value V
============================
 consVal V Tl = consVal V Tl

 < search.

Subgoal 1.2:

Variables: V Tl VOld I1 TlNew
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal VOld Tl)
IsV : is_value V
ULIB : 0 - 1 = I1
ULIB1 : updateListIndex Tl I1 V TlNew
============================
 consVal V Tl = consVal VOld TlNew

 < compute ULIB.

Subgoal 1.2:

Variables: V Tl VOld TlNew
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal VOld Tl)
IsV : is_value V
ULIB : 0 - 1 = -1
ULIB1 : updateListIndex Tl -1 V TlNew
============================
 consVal V Tl = consVal VOld TlNew

 < GEq: apply updateListIndex_geq_0 to _ ULIB1.

Subgoal 1.2:

Variables: V Tl VOld TlNew
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal VOld Tl)
IsV : is_value V
ULIB : 0 - 1 = -1
ULIB1 : updateListIndex Tl -1 V TlNew
GEq : -1 >= 0
============================
 consVal V Tl = consVal VOld TlNew

 < LEq: case GEq.

Subgoal 1.2:

Variables: V Tl VOld TlNew
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal VOld Tl)
IsV : is_value V
ULIB : 0 - 1 = -1
ULIB1 : updateListIndex Tl -1 V TlNew
LEq : 0 <= -1
============================
 consVal V Tl = consVal VOld TlNew

 < case LEq.

Subgoal 2:

Variables: I V OutB I1 TlNew X Tl
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIB : updateListIndex (consVal X Tl) I V OutB
ULIA : I - 1 = I1
ULIA1 : updateListIndex Tl I1 V TlNew *
============================
 consVal X TlNew = OutB

 < ULIB: case ULIB.

Subgoal 2.1:

Variables: V I1 TlNew X Tl
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIA : 0 - 1 = I1
ULIA1 : updateListIndex Tl I1 V TlNew *
============================
 consVal X TlNew = consVal V Tl

 < compute ULIA.

Subgoal 2.1:

Variables: V TlNew X Tl
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIA : 0 - 1 = -1
ULIA1 : updateListIndex Tl -1 V TlNew *
============================
 consVal X TlNew = consVal V Tl

 < G: apply updateListIndex_geq_0 to _ ULIA1.

Subgoal 2.1:

Variables: V TlNew X Tl
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIA : 0 - 1 = -1
ULIA1 : updateListIndex Tl -1 V TlNew *
G : -1 >= 0
============================
 consVal X TlNew = consVal V Tl

 < G: case G.

Subgoal 2.1:

Variables: V TlNew X Tl
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIA : 0 - 1 = -1
ULIA1 : updateListIndex Tl -1 V TlNew *
G : 0 <= -1
============================
 consVal X TlNew = consVal V Tl

 < case G.

Subgoal 2.2:

Variables: I V I1 TlNew X Tl I2 TlNew1
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIA : I - 1 = I1
ULIA1 : updateListIndex Tl I1 V TlNew *
ULIB : I - 1 = I2
ULIB1 : updateListIndex Tl I2 V TlNew1
============================
 consVal X TlNew = consVal X TlNew1

 < apply minus_integer_unique to ULIA ULIB.

Subgoal 2.2:

Variables: I V TlNew X Tl I2 TlNew1
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsL : is_value (consVal X Tl)
IsV : is_value V
ULIA : I - 1 = I2
ULIA1 : updateListIndex Tl I2 V TlNew *
ULIB : I - 1 = I2
ULIB1 : updateListIndex Tl I2 V TlNew1
============================
 consVal X TlNew = consVal X TlNew1

 < case IsL.

Subgoal 2.2:

Variables: I V TlNew X Tl I2 TlNew1
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsV : is_value V
ULIA : I - 1 = I2
ULIA1 : updateListIndex Tl I2 V TlNew *
ULIB : I - 1 = I2
ULIB1 : updateListIndex Tl I2 V TlNew1
H1 : is_value X
H2 : is_value Tl
============================
 consVal X TlNew = consVal X TlNew1

 < apply IH to _ _ ULIA1 ULIB1.

Subgoal 2.2:

Variables: I V X Tl I2 TlNew1
IH : forall L I V OutA OutB,
       is_value L -> is_value V -> updateListIndex L I V OutA * -> updateListIndex L I V OutB ->
       OutA = OutB
IsV : is_value V
ULIA : I - 1 = I2
ULIA1 : updateListIndex Tl I2 V TlNew1 *
ULIB : I - 1 = I2
ULIB1 : updateListIndex Tl I2 V TlNew1
H1 : is_value X
H2 : is_value Tl
============================
 consVal X TlNew1 = consVal X TlNew1

 < search.

Proof completed.

 < Prove matchEval:host:matchInt_unique.

Proof completed.

 < Prove matchEval:host:matchTrue_matchFalse_exclusive.

Proof completed.

 < Prove matchEval:host:matchString_unique.

Proof completed.

 < Prove matchEval:host:matchRec_unique.

Subgoal 2:

Variables: FB
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
IsV : is_value nilVal
MRA : matchRec nilVal [("null", trueVal)] @
MRB : matchRec nilVal FB
============================
 [("null", trueVal)] = FB

 < case MRB.

Subgoal 2:

IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
IsV : is_value nilVal
MRA : matchRec nilVal [("null", trueVal)] @
============================
 [("null", trueVal)] = [("null", trueVal)]

 < search.

Subgoal 3:

Variables: FB V2 V1
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
IsV : is_value (consVal V1 V2)
MRA : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
MRB : matchRec (consVal V1 V2) FB
============================
 [("null", falseVal), ("head", V1), ("tail", V2)] = FB

 < case MRB.

Subgoal 3:

Variables: V2 V1
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
IsV : is_value (consVal V1 V2)
MRA : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
============================
 [("null", falseVal), ("head", V1), ("tail", V2)] = [("null", falseVal), ("head", V1), ("tail", V2)]

 < search.

Proof completed.

 < Prove matchEval:host:matchInt_matchTrue_exclusive.

Proof completed.

 < Prove matchEval:host:matchInt_matchFalse_exclusive.

Proof completed.

 < Prove matchEval:host:matchInt_matchString_exclusive.

Proof completed.

 < Prove matchEval:host:matchInt_matchRec_exclusive.

Proof completed.

 < Prove matchEval:host:matchString_matchTrue_exclusive.

Proof completed.

 < Prove matchEval:host:matchString_matchFalse_exclusive.

Proof completed.

 < Prove matchEval:host:matchString_matchRec_exclusive.

Proof completed.

 < Prove matchEval:host:matchRec_matchTrue_exclusive.

Subgoal 2:

IH : forall V Fs, is_value V -> matchRec V Fs * -> matchTrue V -> false
IsV : is_value nilVal
MR : matchRec nilVal [("null", trueVal)] @
MT : matchTrue nilVal
============================
 false

 < case MT.

Subgoal 3:

Variables: V2 V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchTrue V -> false
IsV : is_value (consVal V1 V2)
MR : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
MT : matchTrue (consVal V1 V2)
============================
 false

 < case MT.

Proof completed.

 < Prove matchEval:host:matchRec_matchFalse_exclusive.

Subgoal 2:

IH : forall V Fs, is_value V -> matchRec V Fs * -> matchFalse V -> false
IsV : is_value nilVal
MR : matchRec nilVal [("null", trueVal)] @
MF : matchFalse nilVal
============================
 false

 < case MF.

Subgoal 3:

Variables: V2 V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchFalse V -> false
IsV : is_value (consVal V1 V2)
MR : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
MF : matchFalse (consVal V1 V2)
============================
 false

 < case MF.

Proof completed.

 < Prove matchEval:host:evalExpr_rel,
         matchEval:host:evalExpr_rel_output,
         matchEval:host:evalStmt_newNameScopes_output,
         matchEval:host:evalStmt_newNameScopes,
         matchEval:host:evalArgs_rel,
         matchEval:host:evalArgs_rel_output,
         matchEval:host:evalRecFields_rel,
         matchEval:host:evalRecFields_rel_output
   with
      iterateList_newNameScopes_output : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsA : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsB : is_list (is_list (is_pair is_string is_value)) EE_B ->
         ILA : iterateList FE EE_A V X Body EE_A' O_A ->
         ILB : iterateList FE EE_B V X Body EE_B' O_B ->
         NNS : newNameScopes N Len EE_A EE_B ->
         O_A = O_B
      on ILA as IH_O_IL,
      iterateList_newNameScopes : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsA : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsB : is_list (is_list (is_pair is_string is_value)) EE_B ->
         ILA : iterateList FE EE_A V X Body EE_A' O_A ->
         ILB : iterateList FE EE_B V X Body EE_B' O_B ->
         NNS : newNameScopes N Len EE_A EE_B ->
         newNameScopes N Len EE_A' EE_B'
      on ILA as IH_C_IL.

Subgoal 1.32:

Variables: FE EE_A EE_B VB O_B Vars Ty
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
EvB : evalExpr FE EE_B (nil Ty) VB O_B
Vars : vars (nil Ty) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
============================
 nilVal = VB

 < case EvB.

Subgoal 1.32:

Variables: FE EE_A EE_B Vars Ty
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
Vars : vars (nil Ty) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
============================
 nilVal = nilVal

 < search.

Subgoal 1.33:

Variables: FE EE_A EE_B VB O_A O_B Vars O1 O2 V2 V1 E2 E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
EvB : evalExpr FE EE_B (cons E1 E2) VB O_B
Vars : vars (cons E1 E2) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
============================
 consVal V1 V2 = VB

 < case IsE.

Subgoal 1.33:

Variables: FE EE_A EE_B VB O_A O_B Vars O1 O2 V2 V1 E2 E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
EvB : evalExpr FE EE_B (cons E1 E2) VB O_B
Vars : vars (cons E1 E2) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
============================
 consVal V1 V2 = VB

 < EvB: case EvB.

Subgoal 1.33:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Vars : vars (cons E1 E2) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
============================
 consVal V1 V2 = consVal V3 V4

 < Vars: case Vars.

Subgoal 1.33:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 consVal V1 V2 = consVal V3 V4

 < apply IH_V_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 forall X V, mem X V5 -> lookupScopes X EE_B V -> lookupScopes X EE_A V

 < intros M L.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V5
L : lookupScopes X EE_B V
============================
 lookupScopes X EE_A V

 < apply mem_append_left to M Vars2.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V5
L : lookupScopes X EE_B V
H3 : mem X Vars
============================
 lookupScopes X EE_A V

 < backchain Rel.

Subgoal 1.33:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V3 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 consVal V3 V2 = consVal V3 V4

 < apply IH_V_E to _ _ _ _ EvA2 EvB1 Vars1 _.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V3 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 forall X V, mem X V6 -> lookupScopes X EE_B V -> lookupScopes X EE_A V

 < intros M L.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V3 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V6
L : lookupScopes X EE_B V
============================
 lookupScopes X EE_A V

 < apply mem_append_right to M Vars2.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V3 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V6
L : lookupScopes X EE_B V
H3 : mem X Vars
============================
 lookupScopes X EE_A V

 < backchain Rel.

Subgoal 1.33:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V4) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V3 O1 *
EvA2 : evalExpr FE EE_A E2 V4 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 consVal V3 V4 = consVal V3 V4

 < search.

Subgoal 1.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
EvB : evalExpr FE EE_B (head E1) VB O_B
Vars : vars (head E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
============================
 VA = VB

 < case IsE.

Subgoal 1.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
EvB : evalExpr FE EE_B (head E1) VB O_B
Vars : vars (head E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
H1 : is_expr E1
============================
 VA = VB

 < EvB: case EvB.

Subgoal 1.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
Vars : vars (head E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
============================
 VA = VB

 < Vars: case Vars.

Subgoal 1.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
Vars : vars E1 Vars
============================
 VA = VB

 < apply IH_V_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 1.34:

Variables: FE EE_A EE_B VB O_A O_B Vars E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VB O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VB Tl1) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
Vars : vars E1 Vars
============================
 VB = VB

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 1.34:

Variables: FE EE_A EE_B VB O_A O_B Vars E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VB O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VB Tl1) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
Vars : vars E1 Vars
H2 : is_value (consVal VB Tl1)
============================
 VB = VB

 < search.

Subgoal 1.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
EvB : evalExpr FE EE_B (tail E1) VB O_B
Vars : vars (tail E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
============================
 VA = VB

 < case IsE.

Subgoal 1.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
EvB : evalExpr FE EE_B (tail E1) VB O_B
Vars : vars (tail E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
H1 : is_expr E1
============================
 VA = VB

 < EvB: case EvB.

Subgoal 1.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
Vars : vars (tail E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
============================
 VA = VB

 < Vars: case Vars.

Subgoal 1.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
Vars : vars E1 Vars
============================
 VA = VB

 < apply IH_V_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 1.35:

Variables: FE EE_A EE_B VB O_A O_B Vars E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VB O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd1 VB) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
Vars : vars E1 Vars
============================
 VB = VB

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 1.35:

Variables: FE EE_A EE_B VB O_A O_B Vars E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VB O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd1 VB) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
Vars : vars E1 Vars
H2 : is_value (consVal Hd1 VB)
============================
 VB = VB

 < search.

Subgoal 1.36:

Variables: FE EE_A EE_B VB O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
============================
 trueVal = VB

 < case IsE.

Subgoal 1.36:

Variables: FE EE_A EE_B VB O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
============================
 trueVal = VB

 < Vars: case Vars.

Subgoal 1.36:

Variables: FE EE_A EE_B VB O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 trueVal = VB

 < EvB: case EvB.

Subgoal 1.36.1:

Variables: FE EE_A EE_B O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 nilVal O_B
============================
 trueVal = trueVal

 < search.

Subgoal 1.36.2:

Variables: FE EE_A EE_B O_A O_B Vars E1 Hd Tl
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 (consVal Hd Tl) O_B
============================
 trueVal = falseVal

 < apply IH_V_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 1.37:

Variables: FE EE_A EE_B VB O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
============================
 falseVal = VB

 < case IsE.

Subgoal 1.37:

Variables: FE EE_A EE_B VB O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
============================
 falseVal = VB

 < Vars: case Vars.

Subgoal 1.37:

Variables: FE EE_A EE_B VB O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 falseVal = VB

 < EvB: case EvB.

Subgoal 1.37.1:

Variables: FE EE_A EE_B O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 nilVal O_B
============================
 falseVal = trueVal

 < apply IH_V_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 1.37.2:

Variables: FE EE_A EE_B O_A O_B Vars Hd Tl E1 Hd1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 (consVal Hd1 Tl1) O_B
============================
 falseVal = falseVal

 < search.

Subgoal 2.32:

Variables: FE EE_A EE_B VB O_B Vars Ty
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
EvB : evalExpr FE EE_B (nil Ty) VB O_B
Vars : vars (nil Ty) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
============================
 [] = O_B

 < case EvB.

Subgoal 2.32:

Variables: FE EE_A EE_B Vars Ty
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
Vars : vars (nil Ty) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
============================
 [] = []

 < search.

Subgoal 2.33:

Variables: FE EE_A EE_B VB O_A O_B Vars O1 O2 V2 V1 E2 E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
EvB : evalExpr FE EE_B (cons E1 E2) VB O_B
Vars : vars (cons E1 E2) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
============================
 O_A = O_B

 < case IsE.

Subgoal 2.33:

Variables: FE EE_A EE_B VB O_A O_B Vars O1 O2 V2 V1 E2 E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
EvB : evalExpr FE EE_B (cons E1 E2) VB O_B
Vars : vars (cons E1 E2) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.33:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Vars : vars (cons E1 E2) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
============================
 O_A = O_B

 < Vars: case Vars.

Subgoal 2.33:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 2.33.1:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 forall X V, mem X V5 -> lookupScopes X EE_B V -> lookupScopes X EE_A V

 < intros M L.

Subgoal 2.33.1:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V5
L : lookupScopes X EE_B V
============================
 lookupScopes X EE_A V

 < apply mem_append_left to M Vars2.

Subgoal 2.33.1:

Variables: FE EE_A EE_B O_A O_B Vars O1 O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V5
L : lookupScopes X EE_B V
H3 : mem X Vars
============================
 lookupScopes X EE_A V

 < backchain Rel.

Subgoal 2.33:

Variables: FE EE_A EE_B O_A O_B Vars O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O3 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA2 EvB1 Vars1 _.

Subgoal 2.33.2:

Variables: FE EE_A EE_B O_A O_B Vars O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O3 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 forall X V, mem X V6 -> lookupScopes X EE_B V -> lookupScopes X EE_A V

 < intros M L.

Subgoal 2.33.2:

Variables: FE EE_A EE_B O_A O_B Vars O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O3 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V6
L : lookupScopes X EE_B V
============================
 lookupScopes X EE_A V

 < apply mem_append_right to M Vars2.

Subgoal 2.33.2:

Variables: FE EE_A EE_B O_A O_B Vars O2 V2 V1 E2 E1 O3 O4 V4 V3 V5 V6 X V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O3 ++ O2 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
M : mem X V6
L : lookupScopes X EE_B V
H3 : mem X Vars
============================
 lookupScopes X EE_A V

 < backchain Rel.

Subgoal 2.33:

Variables: FE EE_A EE_B O_A O_B Vars V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O4 *
EvA3 : O3 ++ O4 = O_A
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 O_A = O_B

 < apply append_unique to EvA3 EvB2.

Subgoal 2.33:

Variables: FE EE_A EE_B O_B Vars V2 V1 E2 E1 O3 O4 V4 V3 V5 V6
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O4 *
EvA3 : O3 ++ O4 = O_B
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = O_B
Vars : vars E1 V5
Vars1 : vars E2 V6
Vars2 : V5 ++ V6 = Vars
============================
 O_B = O_B

 < search.

Subgoal 2.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
EvB : evalExpr FE EE_B (head E1) VB O_B
Vars : vars (head E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
============================
 O_A = O_B

 < case IsE.

Subgoal 2.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
EvB : evalExpr FE EE_B (head E1) VB O_B
Vars : vars (head E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
H1 : is_expr E1
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
Vars : vars (head E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
============================
 O_A = O_B

 < Vars: case Vars.

Subgoal 2.34:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Tl E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
Vars : vars E1 Vars
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB _ _.

Subgoal 2.34:

Variables: FE EE_A EE_B VA VB O_B Vars Tl E1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (head E1) VA O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) O_B *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) O_B
Vars : vars E1 Vars
============================
 O_B = O_B

 < search.

Subgoal 2.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
EvB : evalExpr FE EE_B (tail E1) VB O_B
Vars : vars (tail E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
============================
 O_A = O_B

 < case IsE.

Subgoal 2.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
EvB : evalExpr FE EE_B (tail E1) VB O_B
Vars : vars (tail E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
H1 : is_expr E1
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
Vars : vars (tail E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
============================
 O_A = O_B

 < Vars: case Vars.

Subgoal 2.35:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Hd E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_A *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
Vars : vars E1 Vars
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB _ _.

Subgoal 2.35:

Variables: FE EE_A EE_B VA VB O_B Vars Hd E1 Hd1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (tail E1) VA O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) O_B *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) O_B
Vars : vars E1 Vars
============================
 O_B = O_B

 < search.

Subgoal 2.36:

Variables: FE EE_A EE_B VB O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
============================
 O_A = O_B

 < case IsE.

Subgoal 2.36:

Variables: FE EE_A EE_B VB O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
============================
 O_A = O_B

 < Vars: case Vars.

Subgoal 2.36:

Variables: FE EE_A EE_B VB O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.36.1:

Variables: FE EE_A EE_B O_A O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 nilVal O_B
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB _ _.

Subgoal 2.36.1:

Variables: FE EE_A EE_B O_B Vars E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_B *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 nilVal O_B
============================
 O_B = O_B

 < search.

Subgoal 2.36.2:

Variables: FE EE_A EE_B O_A O_B Vars E1 Hd Tl
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 (consVal Hd Tl) O_B
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB _ _.

Subgoal 2.36.2:

Variables: FE EE_A EE_B O_B Vars E1 Hd Tl
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 nilVal O_B *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 (consVal Hd Tl) O_B
============================
 O_B = O_B

 < search.

Subgoal 2.37:

Variables: FE EE_A EE_B VB O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
============================
 O_A = O_B

 < case IsE.

Subgoal 2.37:

Variables: FE EE_A EE_B VB O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Vars : vars (null E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
============================
 O_A = O_B

 < Vars: case Vars.

Subgoal 2.37:

Variables: FE EE_A EE_B VB O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
EvB : evalExpr FE EE_B (null E1) VB O_B
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.37.1:

Variables: FE EE_A EE_B O_A O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 nilVal O_B
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB _ _.

Subgoal 2.37.1:

Variables: FE EE_A EE_B O_B Vars Hd Tl E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_B *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 nilVal O_B
============================
 O_B = O_B

 < search.

Subgoal 2.37.2:

Variables: FE EE_A EE_B O_A O_B Vars Hd Tl E1 Hd1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 (consVal Hd1 Tl1) O_B
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB _ _.

Subgoal 2.37.2:

Variables: FE EE_A EE_B O_B Vars Hd Tl E1 Hd1 Tl1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O_B *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 (consVal Hd1 Tl1) O_B
============================
 O_B = O_B

 < search.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listUpdate L I E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
============================
 O_A = O_B

 < Is: case IsS.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listUpdate L I E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
============================
 O_A = O_B

 < VI: apply vars_exist to Is1.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA2 EvB1 VI _.

Subgoal 3.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
============================
 forall X V,
   mem X V2 -> lookupScopes X (Scope::EE_B) V -> lookupScopes X (Scope::EE_A) V

 < intros _ LSB.

Subgoal 3.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 X V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
============================
 lookupScopes X (Scope::EE_A) V3

 < apply lookupScopes_is_key to _ LSB.

Subgoal 3.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 X V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
H2 : is_string X
============================
 lookupScopes X (Scope::EE_A) V3

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 3.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 X V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
H2 : is_string X
H3 : lookupScopes X (Scope::EE_A) V3
============================
 lookupScopes X (Scope::EE_A) V3

 < search.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
============================
 O_A = O_B

 < VE: apply vars_exist to Is2.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA4 EvB3 VE _.

Subgoal 3.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
============================
 forall X V,
   mem X V3 -> lookupScopes X (Scope::EE_B) V -> lookupScopes X (Scope::EE_A) V

 < intros _ LSB.

Subgoal 3.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3 X V4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
H1 : mem X V3
LSB : lookupScopes X (Scope::EE_B) V4
============================
 lookupScopes X (Scope::EE_A) V4

 < apply lookupScopes_is_key to _ LSB.

Subgoal 3.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3 X V4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
H1 : mem X V3
LSB : lookupScopes X (Scope::EE_B) V4
H2 : is_string X
============================
 lookupScopes X (Scope::EE_A) V4

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 3.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3 X V4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
H1 : mem X V3
LSB : lookupScopes X (Scope::EE_B) V4
H2 : is_string X
H3 : lookupScopes X (Scope::EE_A) V4
============================
 lookupScopes X (Scope::EE_A) V4

 < search.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O4 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O4 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
============================
 O_A = O_B

 < L: apply newNameScopes_lookupScopes to _ _ _ EvB with
        A = Scope::EE_A.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O4 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O4 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV1
============================
 O_A = O_B

 < apply lookupScopes_unique to L EvA1.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI N1 V LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O4 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O4 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
============================
 O_A = O_B

 < apply append_unique to EvA7 EvB6.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_B N Len Scope LV VI N1 V LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_B @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O3 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O4 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O3 ++ O4 = O_B
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
============================
 O_B = O_B

 < search.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listForeach X L Body) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
============================
 O_A = O_B

 < Is: case IsS.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listForeach X L Body) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
============================
 O_A = O_B

 < V: apply vars_exist to Is1.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB V _.

Subgoal 3.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 forall X V1,
   mem X V -> lookupScopes X (Scope::EE_B) V1 -> lookupScopes X (Scope::EE_A) V1

 < intros _ LSB.

Subgoal 3.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply lookupScopes_is_key to _ LSB.

Subgoal 3.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H2 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 3.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H2 : is_string X1
H3 : lookupScopes X1 (Scope::EE_A) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < search.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O3 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 O_A = O_B

 < apply IH_V_E to _ _ _ _ EvA1 EvB V _.

Subgoal 3.16.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O3 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 forall X V1,
   mem X V -> lookupScopes X (Scope::EE_B) V1 -> lookupScopes X (Scope::EE_A) V1

 < intros _ LSB.

Subgoal 3.16.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O3 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply lookupScopes_is_key to _ LSB.

Subgoal 3.16.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O3 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H2 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 3.16.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O3 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H2 : is_string X1
H3 : lookupScopes X1 (Scope::EE_A) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < search.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O3 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 O_A = O_B

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O3 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : is_value LV1
============================
 O_A = O_B

 < apply IH_O_IL to _ _ _ _ _ _ EvA2 EvB1 _.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O3 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O4 *
EvA3 : O3 ++ O4 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : is_value LV1
============================
 O_A = O_B

 < apply append_unique to EvA3 EvB2.

Subgoal 3.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_B N Len Scope Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_B @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O3 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O4 *
EvA3 : O3 ++ O4 = O_B
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : is_value LV1
============================
 O_B = O_B

 < search.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listUpdate L I E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
============================
 newNameScopes N Len EE_A' EE_B'

 < Is: case IsS.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listUpdate L I E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
============================
 newNameScopes N Len EE_A' EE_B'

 < EvB: case EvB.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
============================
 newNameScopes N Len EE_A' EE_B'

 < VI: apply vars_exist to Is1.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
============================
 newNameScopes N Len EE_A' EE_B'

 < apply IH_V_E to _ _ _ _ EvA2 EvB1 VI _.

Subgoal 4.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
============================
 forall X V,
   mem X V2 -> lookupScopes X (Scope::EE_B) V -> lookupScopes X (Scope::EE_A) V

 < intros _ LSB.

Subgoal 4.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 X V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
============================
 lookupScopes X (Scope::EE_A) V3

 < apply lookupScopes_is_key to _ LSB.

Subgoal 4.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 X V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
H2 : is_string X
============================
 lookupScopes X (Scope::EE_A) V3

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 4.15.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV VI O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 X V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI O1 *
EvA3 : matchInt VI N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
H2 : is_string X
H3 : lookupScopes X (Scope::EE_A) V3
============================
 lookupScopes X (Scope::EE_A) V3

 < search.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
============================
 newNameScopes N Len EE_A' EE_B'

 < VE: apply vars_exist to Is2.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
============================
 newNameScopes N Len EE_A' EE_B'

 < apply IH_V_E to _ _ _ _ EvA4 EvB3 VE _.

Subgoal 4.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
============================
 forall X V,
   mem X V3 -> lookupScopes X (Scope::EE_B) V -> lookupScopes X (Scope::EE_A) V

 < intros _ LSB.

Subgoal 4.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3 X V4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
H1 : mem X V3
LSB : lookupScopes X (Scope::EE_B) V4
============================
 lookupScopes X (Scope::EE_A) V4

 < apply lookupScopes_is_key to _ LSB.

Subgoal 4.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3 X V4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
H1 : mem X V3
LSB : lookupScopes X (Scope::EE_B) V4
H2 : is_string X
============================
 lookupScopes X (Scope::EE_A) V4

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 4.15.2:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 V O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3 X V4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V O2 *
EvA5 : updateListIndex LV N1 V LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
H1 : mem X V3
LSB : lookupScopes X (Scope::EE_B) V4
H2 : is_string X
H3 : lookupScopes X (Scope::EE_A) V4
============================
 lookupScopes X (Scope::EE_A) V4

 < search.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N1 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
============================
 newNameScopes N Len EE_A' EE_B'

 < L: apply newNameScopes_lookupScopes to _ _ _ EvB with
        A = Scope::EE_A.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 O2 LV2 E I L LV1 VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N1 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV1
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV1 N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV1
============================
 newNameScopes N Len EE_A' EE_B'

 < apply lookupScopes_unique to L EvA1.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 O2 LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N1 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
============================
 newNameScopes N Len EE_A' EE_B'

 < apply evalExpr_isValue to _ _ _ EvA2.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 O2 LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N1 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
============================
 newNameScopes N Len EE_A' EE_B'

 < apply evalExpr_isValue to _ _ _ EvA4.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 N1 O2 LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N1 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
============================
 newNameScopes N Len EE_A' EE_B'

 < apply matchInt_unique to _ EvA3 EvB2.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
============================
 newNameScopes N Len EE_A' EE_B'

 < apply lookupScopes_is to _ EvA1.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 LV2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV2
EvA6 : replaceScopes L LV2 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
H3 : is_value LV
============================
 newNameScopes N Len EE_A' EE_B'

 < apply updateListIndex_unique to _ _ EvA5 EvB4.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV3
EvA6 : replaceScopes L LV3 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
H3 : is_value LV
============================
 newNameScopes N Len EE_A' EE_B'

 < NNS': assert newNameScopes N Len (Scope::EE_A) (Scope::EE_B).

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV3
EvA6 : replaceScopes L LV3 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
H3 : is_value LV
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
============================
 newNameScopes N Len EE_A' EE_B'

 < apply updateListIndex_is to _ _ EvA5.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV3
EvA6 : replaceScopes L LV3 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
H3 : is_value LV
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
H4 : is_value LV3
============================
 newNameScopes N Len EE_A' EE_B'

 < R: apply newNameScopes_replaceScopes to _ _ _ _ NNS' EvB5.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3 RA
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV3
EvA6 : replaceScopes L LV3 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
H3 : is_value LV
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
H4 : is_value LV3
R : replaceScopes L LV3 (Scope::EE_A) RA
R1 : newNameScopes N Len RA EE_B'
============================
 newNameScopes N Len EE_A' EE_B'

 < apply replaceScopes_unique to R EvA6.

Subgoal 4.15:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 E I L VI1 O3 N2 V1 O4 LV3 V2 V3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listUpdate L I E) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : lookupScopes L (Scope::EE_A) LV
EvA2 : evalExpr FE (Scope::EE_A) I VI1 O1 *
EvA3 : matchInt VI1 N2
EvA4 : evalExpr FE (Scope::EE_A) E V1 O2 *
EvA5 : updateListIndex LV N2 V1 LV3
EvA6 : replaceScopes L LV3 (Scope::EE_A) EE_A'
EvA7 : O1 ++ O2 = O_A
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
EvB : lookupScopes L (Scope::EE_B) LV
EvB1 : evalExpr FE (Scope::EE_B) I VI1 O3
EvB2 : matchInt VI1 N2
EvB3 : evalExpr FE (Scope::EE_B) E V1 O4
EvB4 : updateListIndex LV N2 V1 LV3
EvB5 : replaceScopes L LV3 (Scope::EE_B) EE_B'
EvB6 : O3 ++ O4 = O_B
VI : vars I V2
VE : vars E V3
L : lookupScopes L (Scope::EE_A) LV
H1 : is_value VI1
H2 : is_value V1
H3 : is_value LV
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
H4 : is_value LV3
R : replaceScopes L LV3 (Scope::EE_A) EE_A'
R1 : newNameScopes N Len EE_A' EE_B'
============================
 newNameScopes N Len EE_A' EE_B'

 < search.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listForeach X L Body) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
============================
 newNameScopes N Len EE_A' EE_B'

 < Is: case IsS.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
EvB : evalStmt FE (Scope::EE_B) (listForeach X L Body) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
============================
 newNameScopes N Len EE_A' EE_B'

 < EvB: case EvB.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
============================
 newNameScopes N Len EE_A' EE_B'

 < V: apply vars_exist to Is1.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 newNameScopes N Len EE_A' EE_B'

 < apply IH_V_E to _ _ _ _ EvA1 EvB V _.

Subgoal 4.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 forall X V1,
   mem X V -> lookupScopes X (Scope::EE_B) V1 -> lookupScopes X (Scope::EE_A) V1

 < intros _ LSB.

Subgoal 4.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply lookupScopes_is_key to _ LSB.

Subgoal 4.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H2 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 4.16.1:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope LV O1 O2 Body L X LV1 O3 O4 V X1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV O1 *
EvA2 : iterateList FE (Scope::EE_A) LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H2 : is_string X1
H3 : lookupScopes X1 (Scope::EE_A) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < search.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O1 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
============================
 newNameScopes N Len EE_A' EE_B'

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O1 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : is_value LV1
============================
 newNameScopes N Len EE_A' EE_B'

 < apply IH_C_IL to _ _ _ _ _ _ EvA2 EvB1 _.

Subgoal 4.16:

Variables: FE EE_A EE_B EE_A' EE_B' O_A O_B N Len Scope O1 O2 Body L X LV1 O3 O4 V
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (listForeach X L Body) EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) L LV1 O1 *
EvA2 : iterateList FE (Scope::EE_A) LV1 X Body EE_A' O2 *
EvA3 : O1 ++ O2 = O_A
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvB : evalExpr FE (Scope::EE_B) L LV1 O3
EvB1 : iterateList FE (Scope::EE_B) LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = O_B
V : vars L V
H1 : is_value LV1
H2 : newNameScopes N Len EE_A' EE_B'
============================
 newNameScopes N Len EE_A' EE_B'

 < search.

Subgoal 9.1:

Variables: FE EE_B X Body EE_A' EE_B' O_B N Len
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
ILB : iterateList FE EE_B nilVal X Body EE_B' O_B
NNS : newNameScopes N Len EE_A' EE_B
============================
 [] = O_B

 < case ILB.

Subgoal 9.1:

Variables: FE X Body EE_A' EE_B' N Len
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B'
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
NNS : newNameScopes N Len EE_A' EE_B'
============================
 [] = []

 < search.

Subgoal 9.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
============================
 O_A = O_B

 < case IsV.

Subgoal 9.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
============================
 O_A = O_B

 < ILB: case ILB.

Subgoal 9.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
============================
 O_A = O_B

 < apply IH_O_S to _ _ _ _ ILA1 ILB _.

Subgoal 9.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
============================
 O_A = O_B

 < NNS+: apply IH_C_S to _ _ _ _ ILA1 ILB _.

Subgoal 9.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len (Scope::EE1) (Scope1::EE2)
============================
 O_A = O_B

 < NNS+: case NNS+.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
============================
 O_A = O_B

 < LenEE_B: apply length_exists_list_pair_string_value to IsB.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
============================
 O_A = O_B

 < IsN2: apply length_is to LenEE_B.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
============================
 O_A = O_B

 < P: apply plus_integer_total to _ IsN2 with
        N1 = 1.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2 N3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = N3
============================
 O_A = O_B

 < LenEE_B+: assert length ([(X, Hd)]::EE_B) N3.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2 N3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = N3
LenEE_B+ : length ([(X, Hd)]::EE_B) N3
============================
 O_A = O_B

 < LenEE2+: apply evalStmt_keep_scopes to _ _ _ ILB LenEE_B+.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2 N3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = N3
LenEE_B+ : length ([(X, Hd)]::EE_B) N3
LenEE2+ : length (Scope1::EE2) N3
============================
 O_A = O_B

 < apply length_unique to LenEE2+ NNS+.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope1::EE2) Len
============================
 O_A = O_B

 < LEq: apply newNameScopes_length to NNS LenEE_B.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope1::EE2) Len
LEq : Len <= N2
============================
 O_A = O_B

 < L: apply lt_plus_one to P _.

Subgoal 9.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope1::EE2) Len
LEq : Len <= N2
L : N2 < Len
============================
 O_A = O_B

 < apply less_lesseq_flip_false to L LEq.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
============================
 O_A = O_B

 < IsEE1+: apply evalStmt_isCtx to _ _ _ ILA1.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
IsEE1+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
============================
 O_A = O_B

 < case IsEE1+.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 O_A = O_B

 < IsEE2+: apply evalStmt_isCtx to _ _ _ ILB.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE2)
============================
 O_A = O_B

 < case IsEE2+.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 O_A = O_B

 < apply IH_O_IL to _ _ _ _ _ _ ILA2 ILB1 _.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O4 *
ILA3 : O3 ++ O4 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 O_A = O_B

 < apply append_unique to ILA3 ILB2.

Subgoal 9.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_B N Len EE1 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_B @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O4 *
ILA3 : O3 ++ O4 = O_B
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 O_B = O_B

 < search.

Subgoal 10.1:

Variables: FE EE_B X Body EE_A' EE_B' O_B N Len
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
ILB : iterateList FE EE_B nilVal X Body EE_B' O_B
NNS : newNameScopes N Len EE_A' EE_B
============================
 newNameScopes N Len EE_A' EE_B'

 < case ILB.

Subgoal 10.1:

Variables: FE X Body EE_A' EE_B' N Len
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B'
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
NNS : newNameScopes N Len EE_A' EE_B'
============================
 newNameScopes N Len EE_A' EE_B'

 < search.

Subgoal 10.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
============================
 newNameScopes N Len EE_A' EE_B'

 < case IsV.

Subgoal 10.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
============================
 newNameScopes N Len EE_A' EE_B'

 < ILB: case ILB.

Subgoal 10.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
============================
 newNameScopes N Len EE_A' EE_B'

 < NNS+: apply IH_C_S to _ _ _ _ ILA1 ILB _.

Subgoal 10.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len (Scope::EE1) (Scope1::EE2)
============================
 newNameScopes N Len EE_A' EE_B'

 < NNS+: case NNS+.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
============================
 newNameScopes N Len EE_A' EE_B'

 < LenEE_B: apply length_exists_list_pair_string_value to IsB.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
============================
 newNameScopes N Len EE_A' EE_B'

 < IsN2: apply length_is to LenEE_B.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
============================
 newNameScopes N Len EE_A' EE_B'

 < P: apply plus_integer_total to _ IsN2 with
        N1 = 1.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2 N3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = N3
============================
 newNameScopes N Len EE_A' EE_B'

 < LenEE_B+: assert length ([(X, Hd)]::EE_B) N3.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2 N3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = N3
LenEE_B+ : length ([(X, Hd)]::EE_B) N3
============================
 newNameScopes N Len EE_A' EE_B'

 < LenEE2+: apply evalStmt_keep_scopes to _ _ _ ILB LenEE_B+.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2 N3
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = N3
LenEE_B+ : length ([(X, Hd)]::EE_B) N3
LenEE2+ : length (Scope1::EE2) N3
============================
 newNameScopes N Len EE_A' EE_B'

 < apply length_unique to LenEE2+ NNS+.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope1::EE2) Len
============================
 newNameScopes N Len EE_A' EE_B'

 < LEq: apply newNameScopes_length to NNS LenEE_B.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope1::EE2) Len
LEq : Len <= N2
============================
 newNameScopes N Len EE_A' EE_B'

 < L: apply lt_plus_one to P _.

Subgoal 10.2.1:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4 N1 SNames BNames N2
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : length (Scope1::EE2) Len
NNS+1 : drop N1 (Scope::EE1) (Scope1::EE2)
NNS+2 : take N1 (Scope::EE1) N
NNS+3 : names N SNames
NNS+4 : names (Scope1::EE2) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N2
IsN2 : is_integer N2
P : 1 + N2 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope1::EE2) Len
LEq : Len <= N2
L : N2 < Len
============================
 newNameScopes N Len EE_A' EE_B'

 < apply less_lesseq_flip_false to L LEq.

Subgoal 10.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
============================
 newNameScopes N Len EE_A' EE_B'

 < IsEE1+: apply evalStmt_isCtx to _ _ _ ILA1.

Subgoal 10.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
IsEE1+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
============================
 newNameScopes N Len EE_A' EE_B'

 < case IsEE1+.

Subgoal 10.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 newNameScopes N Len EE_A' EE_B'

 < IsEE2+: apply evalStmt_isCtx to _ _ _ ILB.

Subgoal 10.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE2)
============================
 newNameScopes N Len EE_A' EE_B'

 < case IsEE2+.

Subgoal 10.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 newNameScopes N Len EE_A' EE_B'

 < apply IH_C_IL to _ _ _ _ _ _ ILA2 ILB1 _.

Subgoal 10.2.2:

Variables: FE EE_A EE_B X Body EE_A' EE_B' O_A O_B N Len EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_IL : forall FE EE_A EE_B V X Body EE_A' EE_B' O_A O_B N Len,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            iterateList FE EE_A V X Body EE_A' O_A * -> iterateList FE EE_B V X Body EE_B' O_B ->
            newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O_A @
NNS : newNameScopes N Len EE_A EE_B
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope1::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = O_A
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = O_B
NNS+ : newNameScopes N Len EE1 EE2
H3 : is_list (is_pair is_string is_value) Scope1
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) EE2
H7 : newNameScopes N Len EE_A' EE_B'
============================
 newNameScopes N Len EE_A' EE_B'

 < search.

Proof completed.

 < Add_Ext_Size matchEval:host:evalExpr,
   matchEval:host:evalArgs,
   matchEval:host:evalRecFields,
   matchEval:host:evalStmt
   with iterateList FE EE V X Body EE' O.

Proof completed.

 < Add_Proj_Rel matchEval:host:evalExpr,
   matchEval:host:evalArgs,
   matchEval:host:evalRecFields,
   matchEval:host:evalStmt
   with iterateList FE EE V X Body EE' O.

Proof completed.

 < Prove matchEval:host:evalExpr_rel_exists_ES,
         matchEval:host:evalStmt_newNameScopes_exists_ES,
         matchEval:host:evalArgs_rel_exists_ES,
         matchEval:host:evalRecFields_rel_exists_ES
   with
      iterateList_newNameScopes_exists_ES : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsA : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsB : is_list (is_list (is_pair is_string is_value)) EE_B ->
         ILB : <iterateList {ES}> FE EE_B V X Body EE_B' O ES ->
         NNS : newNameScopes N Len EE_A EE_B ->
         exists EE_A',
           <iterateList {ES}> FE EE_A V X Body EE_A' O ES
      on ILB as IH_IL.

Subgoal 1.32:

Variables: FE EE_A EE_B Vars Ty
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (nil Ty) nilVal [] 1 @
Vars : vars (nil Ty) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
============================
 <evalExpr {ES}> FE EE_A (nil Ty) nilVal [] 1

 < search.

Subgoal 1.33:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Vars : vars (cons E1 E2) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
============================
 <evalExpr {ES}> FE EE_A (cons E1 E2) (consVal V1 V2) O ES

 < case IsE.

Subgoal 1.33:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Vars : vars (cons E1 E2) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 <evalExpr {ES}> FE EE_A (cons E1 E2) (consVal V1 V2) O ES

 < Vars: case Vars.

Subgoal 1.33:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
============================
 <evalExpr {ES}> FE EE_A (cons E1 E2) (consVal V1 V2) O ES

 < EvA1: apply IH_E to _ _ _ _ EvB3 Vars _ with
           EE_A = EE_A.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
============================
 forall X V1, mem X V3 -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1

 < intros M L.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4 X V5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
M : mem X V3
L : lookupScopes X EE_B V5
============================
 lookupScopes X EE_A V5

 < M': apply mem_append_left to M Vars2.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4 X V5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
M : mem X V3
L : lookupScopes X EE_B V5
M' : mem X Vars
============================
 lookupScopes X EE_A V5

 < apply Rel to M' L.

Subgoal 1.33.1:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4 X V5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
M : mem X V3
L : lookupScopes X EE_B V5
M' : mem X Vars
H3 : lookupScopes X EE_A V5
============================
 lookupScopes X EE_A V5

 < search.

Subgoal 1.33:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
EvA1 : <evalExpr {ES}> FE EE_A E1 V1 O2 N2
============================
 <evalExpr {ES}> FE EE_A (cons E1 E2) (consVal V1 V2) O ES

 < EvA2: apply IH_E to _ _ _ _ EvB4 Vars1 _ with
           EE_A = EE_A.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
EvA1 : <evalExpr {ES}> FE EE_A E1 V1 O2 N2
============================
 forall X V1, mem X V4 -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1

 < intros M L.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4 X V5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
EvA1 : <evalExpr {ES}> FE EE_A E1 V1 O2 N2
M : mem X V4
L : lookupScopes X EE_B V5
============================
 lookupScopes X EE_A V5

 < M': apply mem_append_right to M Vars2.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4 X V5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
EvA1 : <evalExpr {ES}> FE EE_A E1 V1 O2 N2
M : mem X V4
L : lookupScopes X EE_B V5
M' : mem X Vars
============================
 lookupScopes X EE_A V5

 < apply Rel to M' L.

Subgoal 1.33.2:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4 X V5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
EvA1 : <evalExpr {ES}> FE EE_A E1 V1 O2 N2
M : mem X V4
L : lookupScopes X EE_B V5
M' : mem X Vars
H3 : lookupScopes X EE_A V5
============================
 lookupScopes X EE_A V5

 < search.

Subgoal 1.33:

Variables: FE EE_A EE_B O ES Vars N2 N1 N3 O2 O3 V2 V1 E2 E1 V3 V4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (cons E1 E2) (consVal V1 V2) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N3 = ES
EvB2 : N2 + N1 = N3
EvB3 : <evalExpr {ES}> FE EE_B E1 V1 O2 N2 *
EvB4 : <evalExpr {ES}> FE EE_B E2 V2 O3 N1 *
EvB5 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V3
Vars1 : vars E2 V4
Vars2 : V3 ++ V4 = Vars
EvA1 : <evalExpr {ES}> FE EE_A E1 V1 O2 N2
EvA2 : <evalExpr {ES}> FE EE_A E2 V2 O3 N1
============================
 <evalExpr {ES}> FE EE_A (cons E1 E2) (consVal V1 V2) O ES

 < search.

Subgoal 1.34:

Variables: FE EE_A EE_B V O ES Vars N1 Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (head E1) V O ES @
Vars : vars (head E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal V Tl) O N1 *
============================
 <evalExpr {ES}> FE EE_A (head E1) V O ES

 < case IsE.

Subgoal 1.34:

Variables: FE EE_A EE_B V O ES Vars N1 Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (head E1) V O ES @
Vars : vars (head E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal V Tl) O N1 *
H1 : is_expr E1
============================
 <evalExpr {ES}> FE EE_A (head E1) V O ES

 < case Vars.

Subgoal 1.34:

Variables: FE EE_A EE_B V O ES Vars N1 Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (head E1) V O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal V Tl) O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
============================
 <evalExpr {ES}> FE EE_A (head E1) V O ES

 < apply IH_E to _ _ _ _ EvB2 _ Rel.

Subgoal 1.34:

Variables: FE EE_A EE_B V O ES Vars N1 Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (head E1) V O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal V Tl) O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
H3 : <evalExpr {ES}> FE EE_A E1 (consVal V Tl) O N1
============================
 <evalExpr {ES}> FE EE_A (head E1) V O ES

 < search.

Subgoal 1.35:

Variables: FE EE_A EE_B V O ES Vars N1 Hd E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (tail E1) V O ES @
Vars : vars (tail E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd V) O N1 *
============================
 <evalExpr {ES}> FE EE_A (tail E1) V O ES

 < case IsE.

Subgoal 1.35:

Variables: FE EE_A EE_B V O ES Vars N1 Hd E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (tail E1) V O ES @
Vars : vars (tail E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd V) O N1 *
H1 : is_expr E1
============================
 <evalExpr {ES}> FE EE_A (tail E1) V O ES

 < case Vars.

Subgoal 1.35:

Variables: FE EE_A EE_B V O ES Vars N1 Hd E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (tail E1) V O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd V) O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
============================
 <evalExpr {ES}> FE EE_A (tail E1) V O ES

 < apply IH_E to _ _ _ _ EvB2 _ Rel.

Subgoal 1.35:

Variables: FE EE_A EE_B V O ES Vars N1 Hd E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (tail E1) V O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd V) O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
H3 : <evalExpr {ES}> FE EE_A E1 (consVal Hd V) O N1
============================
 <evalExpr {ES}> FE EE_A (tail E1) V O ES

 < search.

Subgoal 1.36:

Variables: FE EE_A EE_B O ES Vars N1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) trueVal O ES @
Vars : vars (null E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 nilVal O N1 *
============================
 <evalExpr {ES}> FE EE_A (null E1) trueVal O ES

 < case IsE.

Subgoal 1.36:

Variables: FE EE_A EE_B O ES Vars N1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) trueVal O ES @
Vars : vars (null E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 nilVal O N1 *
H1 : is_expr E1
============================
 <evalExpr {ES}> FE EE_A (null E1) trueVal O ES

 < case Vars.

Subgoal 1.36:

Variables: FE EE_A EE_B O ES Vars N1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) trueVal O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 nilVal O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
============================
 <evalExpr {ES}> FE EE_A (null E1) trueVal O ES

 < apply IH_E to _ _ _ _ EvB2 _ Rel.

Subgoal 1.36:

Variables: FE EE_A EE_B O ES Vars N1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) trueVal O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 nilVal O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
H3 : <evalExpr {ES}> FE EE_A E1 nilVal O N1
============================
 <evalExpr {ES}> FE EE_A (null E1) trueVal O ES

 < search.

Subgoal 1.37:

Variables: FE EE_A EE_B O ES Vars N1 Hd Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) falseVal O ES @
Vars : vars (null E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd Tl) O N1 *
============================
 <evalExpr {ES}> FE EE_A (null E1) falseVal O ES

 < case IsE.

Subgoal 1.37:

Variables: FE EE_A EE_B O ES Vars N1 Hd Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) falseVal O ES @
Vars : vars (null E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd Tl) O N1 *
H1 : is_expr E1
============================
 <evalExpr {ES}> FE EE_A (null E1) falseVal O ES

 < case Vars.

Subgoal 1.37:

Variables: FE EE_A EE_B O ES Vars N1 Hd Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) falseVal O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd Tl) O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
============================
 <evalExpr {ES}> FE EE_A (null E1) falseVal O ES

 < apply IH_E to _ _ _ _ EvB2 _ Rel.

Subgoal 1.37:

Variables: FE EE_A EE_B O ES Vars N1 Hd Tl E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (null E1) falseVal O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 (consVal Hd Tl) O N1 *
H1 : is_expr E1
H2 : vars E1 Vars
H3 : <evalExpr {ES}> FE EE_A E1 (consVal Hd Tl) O N1
============================
 <evalExpr {ES}> FE EE_A (null E1) falseVal O ES

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < Is: case IsS.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < LA: apply newNameScopes_lookupScopes to IsA _ _ EvB3.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < VI: apply vars_exist to Is1.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < EvA1: apply IH_E to _ _ IsA _ EvB4 VI _ with
           EE_A = Scope::EE_A.

Subgoal 2.15.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
============================
 forall X V2,
   mem X V1 -> lookupScopes X (Scope::EE_B) V2 -> lookupScopes X (Scope::EE_A) V2

 < intros _ LSB.

Subgoal 2.15.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 X V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
H1 : mem X V1
LSB : lookupScopes X (Scope::EE_B) V2
============================
 lookupScopes X (Scope::EE_A) V2

 < apply lookupScopes_is_key to _ LSB.

Subgoal 2.15.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 X V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
H1 : mem X V1
LSB : lookupScopes X (Scope::EE_B) V2
H2 : is_string X
============================
 lookupScopes X (Scope::EE_A) V2

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 2.15.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 X V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
H1 : mem X V1
LSB : lookupScopes X (Scope::EE_B) V2
H2 : is_string X
H3 : lookupScopes X (Scope::EE_A) V2
============================
 lookupScopes X (Scope::EE_A) V2

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < EvB1': apply drop_ext_size_evalExpr to EvB4.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < EvA1': apply drop_ext_size_evalExpr to EvA1.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < VE: apply vars_exist to Is2.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < EvA2: apply IH_E to _ _ _ _ EvB6 VE _ with
           EE_A = Scope::EE_A.

Subgoal 2.15.2:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
============================
 forall X V1,
   mem X V2 -> lookupScopes X (Scope::EE_B) V1 -> lookupScopes X (Scope::EE_A) V1

 < intros _ LSB.

Subgoal 2.15.2:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2 X V3
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
============================
 lookupScopes X (Scope::EE_A) V3

 < apply lookupScopes_is_key to _ LSB.

Subgoal 2.15.2:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2 X V3
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
H2 : is_string X
============================
 lookupScopes X (Scope::EE_A) V3

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 2.15.2:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2 X V3
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
H1 : mem X V2
LSB : lookupScopes X (Scope::EE_B) V3
H2 : is_string X
H3 : lookupScopes X (Scope::EE_A) V3
============================
 lookupScopes X (Scope::EE_A) V3

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < EvB2': apply drop_ext_size_evalExpr to EvB6.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < EvA2': apply drop_ext_size_evalExpr to EvA2.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
EvA2' : evalExpr FE (Scope::EE_A) E V O3
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < apply evalExpr_isValue to _ _ _ EvB2'.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
EvA2' : evalExpr FE (Scope::EE_A) E V O3
H1 : is_value V
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < apply lookupScopes_is to _ EvB3.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
EvA2' : evalExpr FE (Scope::EE_A) E V O3
H1 : is_value V
H2 : is_value LV
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < apply updateListIndex_is to _ _ EvB7.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
EvA2' : evalExpr FE (Scope::EE_A) E V O3
H1 : is_value V
H2 : is_value LV
H3 : is_value LV2
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < NNS': assert newNameScopes N Len (Scope::EE_A) (Scope::EE_B).

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
EvA2' : evalExpr FE (Scope::EE_A) E V O3
H1 : is_value V
H2 : is_value LV
H3 : is_value LV2
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < apply newNameScopes_replaceScopes to _ _ _ _ NNS' EvB8.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L V1 V2 RA
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listUpdate L I E) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N3 + N2 = N4
EvB3 : lookupScopes L (Scope::EE_B) LV
EvB4 : <evalExpr {ES}> FE (Scope::EE_B) I VI O2 N3 *
EvB5 : matchInt VI N1
EvB6 : <evalExpr {ES}> FE (Scope::EE_B) E V O3 N2 *
EvB7 : updateListIndex LV N1 V LV2
EvB8 : replaceScopes L LV2 (Scope::EE_B) EE_B'
EvB9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
LA : lookupScopes L (Scope::EE_A) LV
VI : vars I V1
EvA1 : <evalExpr {ES}> FE (Scope::EE_A) I VI O2 N3
EvB1' : evalExpr FE (Scope::EE_B) I VI O2
EvA1' : evalExpr FE (Scope::EE_A) I VI O2
VE : vars E V2
EvA2 : <evalExpr {ES}> FE (Scope::EE_A) E V O3 N2
EvB2' : evalExpr FE (Scope::EE_B) E V O3
EvA2' : evalExpr FE (Scope::EE_A) E V O3
H1 : is_value V
H2 : is_value LV
H3 : is_value LV2
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
H4 : replaceScopes L LV2 (Scope::EE_A) RA
H5 : newNameScopes N Len RA EE_B'
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (listUpdate L I E) EE_A' O ES

 < search.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < Is: case IsS.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < EvE: apply drop_ext_size_evalExpr to EvB3.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < apply evalExpr_isValue to _ _ _ EvE.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < V: apply vars_exist to Is1.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < apply IH_E to _ _ _ _ EvB3 V _ with
     EE_A = Scope::EE_A.

Subgoal 2.16.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
============================
 forall X V1,
   mem X V -> lookupScopes X (Scope::EE_B) V1 -> lookupScopes X (Scope::EE_A) V1

 < intros _ LSB.

Subgoal 2.16.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V X1 V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
H2 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply lookupScopes_is_key to _ LSB.

Subgoal 2.16.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V X1 V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
H2 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H3 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < apply newNameScopes_lookupScopes to _ _ _ LSB.

Subgoal 2.16.1:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V X1 V1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
H2 : mem X1 V
LSB : lookupScopes X1 (Scope::EE_B) V1
H3 : is_string X1
H4 : lookupScopes X1 (Scope::EE_A) V1
============================
 lookupScopes X1 (Scope::EE_A) V1

 < search.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
H2 : <evalExpr {ES}> FE (Scope::EE_A) L LV O2 N2
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < NNS+: assert newNameScopes N Len (Scope::EE_A) (Scope::EE_B).

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
H2 : <evalExpr {ES}> FE (Scope::EE_A) L LV O2 N2
NNS+ : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < apply IH_IL to _ _ _ _ _ _ EvB4 NNS+.

Subgoal 2.16:

Variables: FE EE_A EE_B EE_B' O N Len Scope ES N2 N3 N4 LV O2 O3 Body L X V EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (listForeach X L Body) EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N4 = ES
EvB2 : N2 + N3 = N4
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) L LV O2 N2 *
EvB4 : <iterateList {ES}> FE (Scope::EE_B) LV X Body EE_B' O3 N3 *
EvB5 : O2 ++ O3 = O
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
EvE : evalExpr FE (Scope::EE_B) L LV O2
H1 : is_value LV
V : vars L V
H2 : <evalExpr {ES}> FE (Scope::EE_A) L LV O2 N2
NNS+ : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
H3 : <iterateList {ES}> FE (Scope::EE_A) LV X Body EE_A' O3 N3
============================
 exists EE_A',
   <evalStmt {ES}> FE (Scope::EE_A) (listForeach X L Body) EE_A' O ES

 < search.

Subgoal 5.1:

Variables: FE EE_A X Body EE_B' N Len
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B'
ILB : <iterateList {ES}> FE EE_B' nilVal X Body EE_B' [] 0 @
NNS : newNameScopes N Len EE_A EE_B'
============================
 exists EE_A', <iterateList {ES}> FE EE_A nilVal X Body EE_A' [] 0

 < search.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < case IsV.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < EvA: apply IH_S to _ _ _ _ ILB2 NNS.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < EvB': apply drop_ext_size_evalStmt to ILB2.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < EvA': apply drop_ext_size_evalStmt to EvA.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < IsEE1+: apply evalStmt_isCtx to _ _ _ EvB'.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
IsEE1+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < case IsEE1+.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < NNS+: apply evalStmt_newNameScopes to _ _ _ _ EvA' EvB' NNS.

Subgoal 5.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A'
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : newNameScopes N Len EE_A' (Scope::EE1)
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < NNS+: case NNS+.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < LenEE_B: apply length_exists_list_pair_string_value to IsB.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < IsN2: apply length_is to LenEE_B.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < P: apply plus_integer_total to _ IsN2 with
        N1 = 1.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4 N5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
P : 1 + N4 = N5
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < LenEE_B+: assert length ([(X, Hd)]::EE_B) N5.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4 N5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
P : 1 + N4 = N5
LenEE_B+ : length ([(X, Hd)]::EE_B) N5
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < LenEE2+: apply evalStmt_keep_scopes to _ _ _ EvB' LenEE_B+.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4 N5
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
P : 1 + N4 = N5
LenEE_B+ : length ([(X, Hd)]::EE_B) N5
LenEE2+ : length (Scope::EE1) N5
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < apply length_unique to LenEE2+ NNS+.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
P : 1 + N4 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope::EE1) Len
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < LEq: apply newNameScopes_length to NNS LenEE_B.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
P : 1 + N4 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope::EE1) Len
LEq : Len <= N4
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < L: apply lt_plus_one to P _.

Subgoal 5.2.1:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd EE_A' N1 SNames BNames N4
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body EE_A' O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body EE_A' O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : length (Scope::EE1) Len
NNS+1 : drop N1 EE_A' (Scope::EE1)
NNS+2 : take N1 EE_A' N
NNS+3 : names N SNames
NNS+4 : names (Scope::EE1) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
LenEE_B : length EE_B N4
IsN2 : is_integer N4
P : 1 + N4 = Len
LenEE_B+ : length ([(X, Hd)]::EE_B) Len
LenEE2+ : length (Scope::EE1) Len
LEq : Len <= N4
L : N4 < Len
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < apply less_lesseq_flip_false to L LEq.

Subgoal 5.2.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd AR
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : newNameScopes N Len AR EE1
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < IsAR+: apply evalStmt_isCtx to _ _ _ EvA'.

Subgoal 5.2.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd AR
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : newNameScopes N Len AR EE1
IsAR+ : is_list (is_list (is_pair is_string is_value)) (Scope::AR)
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < case IsAR+.

Subgoal 5.2.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd AR
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : newNameScopes N Len AR EE1
H5 : is_list (is_pair is_string is_value) Scope
H6 : is_list (is_list (is_pair is_string is_value)) AR
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < apply IH_IL to _ _ _ _ _ _ ILB3 NNS+.

Subgoal 5.2.2:

Variables: FE EE_A EE_B X Body EE_B' O N Len ES N2 N3 Scope EE1 O2 O3 Tl Hd AR EE_A'1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IH_IL : forall FE EE_A EE_B V X Body EE_B' O N Len ES,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <iterateList {ES}> FE EE_B V X Body EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
          exists EE_A', <iterateList {ES}> FE EE_A V X Body EE_A' O ES
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
ILB : <iterateList {ES}> FE EE_B (consVal Hd Tl) X Body EE_B' O ES @
NNS : newNameScopes N Len EE_A EE_B
ILB1 : N2 + N3 = ES
ILB2 : <evalStmt {ES}> FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2 N2 *
ILB3 : <iterateList {ES}> FE EE1 Tl X Body EE_B' O3 N3 *
ILB4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
EvA : <evalStmt {ES}> FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2 N2
EvB' : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope::EE1) O2
EvA' : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::AR) O2
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
NNS+ : newNameScopes N Len AR EE1
H5 : is_list (is_pair is_string is_value) Scope
H6 : is_list (is_list (is_pair is_string is_value)) AR
H7 : <iterateList {ES}> FE AR Tl X Body EE_A'1 O3 N3
============================
 exists EE_A', <iterateList {ES}> FE EE_A (consVal Hd Tl) X Body EE_A' O ES

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_scopes_same,
         matchEval:host:evalStmt_scopes_same,
         matchEval:host:evalStmt_scopes_same_ctx,
         matchEval:host:evalArgs_scopes_same,
         matchEval:host:evalRecFields_scopes_same
   with
      iterateList_scopes_same : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsA : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsB : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SS : scopes_same EE_A EE_B ->
         ILA : iterateList FE EE_A V X Body EE_A' OA ->
         ILB : iterateList FE EE_B V X Body EE_B' OB ->
         OA = OB
      on ILA as IH_IL,
      iterateList_scopes_same_ctx : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsA : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsB : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SS : scopes_same EE_A EE_B ->
         ILA : iterateList FE EE_A V X Body EE_A' OA ->
         ILB : iterateList FE EE_B V X Body EE_B' OB ->
         scopes_same EE_A' EE_B'
      on ILA as IH_IL_C.

Subgoal 1.32:

Variables: FE EE_A EE_B VB OB Ty
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
EvB : evalExpr FE EE_B (nil Ty) VB OB
============================
 nilVal = VB /\ [] = OB

 < case EvB.

Subgoal 1.32:

Variables: FE EE_A EE_B Ty
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
============================
 nilVal = nilVal /\ [] = []

 < search.

Subgoal 1.33:

Variables: FE EE_A OA EE_B VB OB O1 O2 V2 V1 E2 E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) OA @
EvB : evalExpr FE EE_B (cons E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = OA
============================
 consVal V1 V2 = VB /\ OA = OB

 < case IsE.

Subgoal 1.33:

Variables: FE EE_A OA EE_B VB OB O1 O2 V2 V1 E2 E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) OA @
EvB : evalExpr FE EE_B (cons E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 consVal V1 V2 = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.33:

Variables: FE EE_A OA EE_B OB O1 O2 V2 V1 E2 E1 O3 O4 V4 V3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) OA @
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = OB
============================
 consVal V1 V2 = consVal V3 V4 /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.33:

Variables: FE EE_A OA EE_B OB O2 V2 E2 E1 O3 O4 V4 V3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V2) OA @
EvA1 : evalExpr FE EE_A E1 V3 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = OB
============================
 consVal V3 V2 = consVal V3 V4 /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA2 EvB1.

Subgoal 1.33:

Variables: FE EE_A OA EE_B OB E2 E1 O3 O4 V4 V3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V4) OA @
EvA1 : evalExpr FE EE_A E1 V3 O3 *
EvA2 : evalExpr FE EE_A E2 V4 O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = OB
============================
 consVal V3 V4 = consVal V3 V4 /\ OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 1.33:

Variables: FE EE_A EE_B OB E2 E1 O3 O4 V4 V3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V3 V4) OB @
EvA1 : evalExpr FE EE_A E1 V3 O3 *
EvA2 : evalExpr FE EE_A E2 V4 O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : O3 ++ O4 = OB
============================
 consVal V3 V4 = consVal V3 V4 /\ OB = OB

 < search.

Subgoal 1.34:

Variables: FE EE_A VA OA EE_B VB OB Tl E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) VA OA @
EvB : evalExpr FE EE_B (head E1) VB OB
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) OA *
============================
 VA = VB /\ OA = OB

 < case IsE.

Subgoal 1.34:

Variables: FE EE_A VA OA EE_B VB OB Tl E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) VA OA @
EvB : evalExpr FE EE_B (head E1) VB OB
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) OA *
H1 : is_expr E1
============================
 VA = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.34:

Variables: FE EE_A VA OA EE_B VB OB Tl E1 Tl1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) VA OA @
EvA1 : evalExpr FE EE_A E1 (consVal VA Tl) OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) OB
============================
 VA = VB /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.34:

Variables: FE EE_A EE_B VB OB E1 Tl1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) VB OB @
EvA1 : evalExpr FE EE_A E1 (consVal VB Tl1) OB *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal VB Tl1) OB
============================
 VB = VB /\ OB = OB

 < search.

Subgoal 1.35:

Variables: FE EE_A VA OA EE_B VB OB Hd E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) VA OA @
EvB : evalExpr FE EE_B (tail E1) VB OB
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) OA *
============================
 VA = VB /\ OA = OB

 < case IsE.

Subgoal 1.35:

Variables: FE EE_A VA OA EE_B VB OB Hd E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) VA OA @
EvB : evalExpr FE EE_B (tail E1) VB OB
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) OA *
H1 : is_expr E1
============================
 VA = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.35:

Variables: FE EE_A VA OA EE_B VB OB Hd E1 Hd1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) VA OA @
EvA1 : evalExpr FE EE_A E1 (consVal Hd VA) OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) OB
============================
 VA = VB /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.35:

Variables: FE EE_A EE_B VB OB E1 Hd1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) VB OB @
EvA1 : evalExpr FE EE_A E1 (consVal Hd1 VB) OB *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 VB) OB
============================
 VB = VB /\ OB = OB

 < search.

Subgoal 1.36:

Variables: FE EE_A OA EE_B VB OB E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal OA @
EvB : evalExpr FE EE_B (null E1) VB OB
EvA1 : evalExpr FE EE_A E1 nilVal OA *
============================
 trueVal = VB /\ OA = OB

 < case IsE.

Subgoal 1.36:

Variables: FE EE_A OA EE_B VB OB E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal OA @
EvB : evalExpr FE EE_B (null E1) VB OB
EvA1 : evalExpr FE EE_A E1 nilVal OA *
H1 : is_expr E1
============================
 trueVal = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.36.1:

Variables: FE EE_A OA EE_B OB E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal OA @
EvA1 : evalExpr FE EE_A E1 nilVal OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 nilVal OB
============================
 trueVal = trueVal /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.36.1:

Variables: FE EE_A EE_B OB E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal OB @
EvA1 : evalExpr FE EE_A E1 nilVal OB *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 nilVal OB
============================
 trueVal = trueVal /\ OB = OB

 < search.

Subgoal 1.36.2:

Variables: FE EE_A OA EE_B OB E1 Hd Tl
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal OA @
EvA1 : evalExpr FE EE_A E1 nilVal OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd Tl) OB
============================
 trueVal = falseVal /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.37:

Variables: FE EE_A OA EE_B VB OB Hd Tl E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal OA @
EvB : evalExpr FE EE_B (null E1) VB OB
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) OA *
============================
 falseVal = VB /\ OA = OB

 < case IsE.

Subgoal 1.37:

Variables: FE EE_A OA EE_B VB OB Hd Tl E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal OA @
EvB : evalExpr FE EE_B (null E1) VB OB
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) OA *
H1 : is_expr E1
============================
 falseVal = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.37.1:

Variables: FE EE_A OA EE_B OB Hd Tl E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 nilVal OB
============================
 falseVal = trueVal /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.37.2:

Variables: FE EE_A OA EE_B OB Hd Tl E1 Hd1 Tl1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 Tl1) OB
============================
 falseVal = falseVal /\ OA = OB

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 1.37.2:

Variables: FE EE_A EE_B OB E1 Hd1 Tl1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal OB @
EvA1 : evalExpr FE EE_A E1 (consVal Hd1 Tl1) OB *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 (consVal Hd1 Tl1) OB
============================
 falseVal = falseVal /\ OB = OB

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV VI O1 N V O2 LV2 E I L
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvB : evalStmt FE EE_B (listUpdate L I E) EE_B' OB
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O1 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsS.

Subgoal 2.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV VI O1 N V O2 LV2 E I L
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvB : evalStmt FE EE_B (listUpdate L I E) EE_B' OB
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O1 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O1 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 OA = OB

 < EvB: case EvB.

Subgoal 2.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV VI O1 N V O2 LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O1 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O1 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ EvA2 EvB1.

Subgoal 2.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV N V O2 LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 OA = OB

 < apply scopes_same_lookupScopes to _ _ SS EvA1 EvB.

Subgoal 2.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB N V O2 LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV1 N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ EvA4 EvB3.

Subgoal 2.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB N LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA7 EvB6.

Subgoal 2.15:

Variables: FE EE_A EE_A' EE_B EE_B' OB N LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OB @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OB
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 2.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV O1 O2 Body L X
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvB : evalStmt FE EE_B (listForeach X L Body) EE_B' OB
EvA1 : evalExpr FE EE_A L LV O1 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsS.

Subgoal 2.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV O1 O2 Body L X
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvB : evalStmt FE EE_B (listForeach X L Body) EE_B' OB
EvA1 : evalExpr FE EE_A L LV O1 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 OA = OB

 < EvB: case EvB.

Subgoal 2.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV O1 O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV O1 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ SS EvA1 EvB.

Subgoal 2.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 2.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
H4 : is_value LV1
============================
 OA = OB

 < apply IH_IL to _ _ _ _ _ _ SS EvA2 EvB1.

Subgoal 2.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
H4 : is_value LV1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 2.16:

Variables: FE EE_A EE_A' EE_B EE_B' OB Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OB @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
H4 : is_value LV1
============================
 OB = OB

 < search.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV VI O1 N V O2 LV2 E I L
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvB : evalStmt FE EE_B (listUpdate L I E) EE_B' OB
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O1 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O1 ++ O2 = OA
============================
 scopes_same EE_A' EE_B'

 < case IsS.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV VI O1 N V O2 LV2 E I L
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvB : evalStmt FE EE_B (listUpdate L I E) EE_B' OB
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O1 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O1 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 scopes_same EE_A' EE_B'

 < EvB: case EvB.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV VI O1 N V O2 LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O1 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O1 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < apply IH_E to _ _ _ _ _ EvA2 EvB1.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV N V O2 LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V O2 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O2 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < apply IH_E to _ _ _ _ _ EvA4 EvB3.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV N LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV N V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < apply scopes_same_lookupScopes to _ _ SS EvA1 EvB.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB N LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < apply evalExpr_isValue to _ _ _ EvA2.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB N LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
H4 : is_value VI1
============================
 scopes_same EE_A' EE_B'

 < apply matchInt_unique to _ EvA3 EvB2.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N1 V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
H4 : is_value VI1
============================
 scopes_same EE_A' EE_B'

 < apply evalExpr_isValue to _ _ _ EvA4.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N1 V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
H4 : is_value VI1
H5 : is_value V1
============================
 scopes_same EE_A' EE_B'

 < apply lookupScopes_is to _ EvA1.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV2 E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N1 V1 LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
H4 : is_value VI1
H5 : is_value V1
H6 : is_value LV1
============================
 scopes_same EE_A' EE_B'

 < apply updateListIndex_unique to _ _ EvA5 EvB4.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N1 V1 LV3
EvA6 : replaceScopes L LV3 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
H4 : is_value VI1
H5 : is_value V1
H6 : is_value LV1
============================
 scopes_same EE_A' EE_B'

 < apply scopes_same_replaceScopes_scopes_same to _ _ _ _ EvA6 EvB5.

Subgoal 3.15:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB E I L LV1 VI1 O3 N1 V1 O4 LV3
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' OA @
EvA1 : lookupScopes L EE_A LV1
EvA2 : evalExpr FE EE_A I VI1 O3 *
EvA3 : matchInt VI1 N1
EvA4 : evalExpr FE EE_A E V1 O4 *
EvA5 : updateListIndex LV1 N1 V1 LV3
EvA6 : replaceScopes L LV3 EE_A EE_A'
EvA7 : O3 ++ O4 = OA
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB : lookupScopes L EE_B LV1
EvB1 : evalExpr FE EE_B I VI1 O3
EvB2 : matchInt VI1 N1
EvB3 : evalExpr FE EE_B E V1 O4
EvB4 : updateListIndex LV1 N1 V1 LV3
EvB5 : replaceScopes L LV3 EE_B EE_B'
EvB6 : O3 ++ O4 = OB
H4 : is_value VI1
H5 : is_value V1
H6 : is_value LV1
H7 : scopes_same EE_A' EE_B'
============================
 scopes_same EE_A' EE_B'

 < search.

Subgoal 3.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV O1 O2 Body L X
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvB : evalStmt FE EE_B (listForeach X L Body) EE_B' OB
EvA1 : evalExpr FE EE_A L LV O1 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = OA
============================
 scopes_same EE_A' EE_B'

 < case IsS.

Subgoal 3.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV O1 O2 Body L X
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvB : evalStmt FE EE_B (listForeach X L Body) EE_B' OB
EvA1 : evalExpr FE EE_A L LV O1 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 scopes_same EE_A' EE_B'

 < EvB: case EvB.

Subgoal 3.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB LV O1 O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV O1 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < apply IH_E to _ _ _ _ _ EvA1 EvB.

Subgoal 3.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 3.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
H4 : is_value LV1
============================
 scopes_same EE_A' EE_B'

 < apply IH_IL_C to _ _ _ _ _ _ SS EvA2 EvB1.

Subgoal 3.16:

Variables: FE EE_A EE_A' OA EE_B EE_B' OB O2 Body L X LV1 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' OA @
EvA1 : evalExpr FE EE_A L LV1 O3 *
EvA2 : iterateList FE EE_A LV1 X Body EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
EvB : evalExpr FE EE_B L LV1 O3
EvB1 : iterateList FE EE_B LV1 X Body EE_B' O4
EvB2 : O3 ++ O4 = OB
H4 : is_value LV1
H5 : scopes_same EE_A' EE_B'
============================
 scopes_same EE_A' EE_B'

 < search.

Subgoal 6.1:

Variables: X Body FE EE_A' EE_B EE_B' OB
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A' EE_B
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
ILB : iterateList FE EE_B nilVal X Body EE_B' OB
============================
 [] = OB

 < case ILB.

Subgoal 6.1:

Variables: X Body FE EE_A' EE_B'
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B'
SS : scopes_same EE_A' EE_B'
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
============================
 [] = []

 < search.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' OB
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsV.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' OB
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
============================
 OA = OB

 < ILB: case ILB.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ ILA1 ILB.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
============================
 OA = OB

 < SS+: apply IH_S_C to _ _ _ _ _ ILA1 ILB.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
SS+ : scopes_same (Scope::EE1) (Scope1::EE2)
============================
 OA = OB

 < case SS+.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
============================
 OA = OB

 < IsEE1+: apply evalStmt_isCtx to _ _ _ ILA1.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
IsEE1+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 OA = OB

 < case IsEE1+.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 OA = OB

 < IsEE2+: apply evalStmt_isCtx to _ _ _ ILB.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE2)
============================
 OA = OB

 < case IsEE2+.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O3 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope1
H9 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 OA = OB

 < apply IH_IL to _ _ _ _ _ _ _ ILA2 ILB1.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O4 *
ILA3 : O3 ++ O4 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope1
H9 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 OA = OB

 < apply append_unique to ILA3 ILB2.

Subgoal 6.2:

Variables: X Body FE EE_A EE_A' EE_B EE_B' OB Scope EE1 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OB @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O3 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O4 *
ILA3 : O3 ++ O4 = OB
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope1
H9 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 OB = OB

 < search.

Subgoal 7.1:

Variables: X Body FE EE_A' EE_B EE_B' OB
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A' EE_B
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
ILB : iterateList FE EE_B nilVal X Body EE_B' OB
============================
 scopes_same EE_A' EE_B'

 < case ILB.

Subgoal 7.1:

Variables: X Body FE EE_A' EE_B'
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B'
SS : scopes_same EE_A' EE_B'
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
============================
 scopes_same EE_A' EE_B'

 < search.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' OB
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
============================
 scopes_same EE_A' EE_B'

 < case IsV.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILB : iterateList FE EE_B (consVal Hd Tl) X Body EE_B' OB
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
============================
 scopes_same EE_A' EE_B'

 < ILB: case ILB.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
============================
 scopes_same EE_A' EE_B'

 < SS+: apply IH_S_C to _ _ _ _ _ ILA1 ILB.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
SS+ : scopes_same (Scope::EE1) (Scope1::EE2)
============================
 scopes_same EE_A' EE_B'

 < case SS+.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
============================
 scopes_same EE_A' EE_B'

 < IsEE1+: apply evalStmt_isCtx to _ _ _ ILA1.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
IsEE1+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 scopes_same EE_A' EE_B'

 < case IsEE1+.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 scopes_same EE_A' EE_B'

 < IsEE2+: apply evalStmt_isCtx to _ _ _ ILB.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE2)
============================
 scopes_same EE_A' EE_B'

 < case IsEE2+.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope1
H9 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 scopes_same EE_A' EE_B'

 < apply IH_IL_C to _ _ _ _ _ _ _ ILA2 ILB1.

Subgoal 7.2:

Variables: X Body FE EE_A EE_A' OA EE_B EE_B' OB Scope EE1 O1 O2 Tl Hd Scope1 EE2 O3 O4
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IH_IL : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
          OA = OB
IH_IL_C : forall V X Body FE EE_A EE_A' OA EE_B EE_B' OB,
            is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' OA * -> iterateList FE EE_B V X Body EE_B' OB ->
            scopes_same EE_A' EE_B'
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' OA @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O1 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O2 *
ILA3 : O1 ++ O2 = OA
H1 : is_value Hd
H2 : is_value Tl
ILB : evalStmt FE ([(X, Hd)]::EE_B) Body (Scope1::EE2) O3
ILB1 : iterateList FE EE2 Tl X Body EE_B' O4
ILB2 : O3 ++ O4 = OB
H3 : forall X V, lookup Scope X V -> lookup Scope1 X V
H4 : forall X V, lookup Scope1 X V -> lookup Scope X V
H5 : scopes_same EE1 EE2
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope1
H9 : is_list (is_list (is_pair is_string is_value)) EE2
H10 : scopes_same EE_A' EE_B'
============================
 scopes_same EE_A' EE_B'

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_scopes_same_exists,
         matchEval:host:evalStmt_scopes_same_exists,
         matchEval:host:evalArgs_scopes_same_exists,
         matchEval:host:evalRecFields_scopes_same_exists
   with
      iterateList_scopes_same_exists : forall V X Body FE EE_A EE_A' O EE_B,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsA : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsB : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SS : scopes_same EE_A EE_B ->
         ILA : iterateList FE EE_A V X Body EE_A' O ->
         exists EE_B',
           iterateList FE EE_B V X Body EE_B' O
      on ILA as IH_IL.

Subgoal 1.32:

Variables: FE EE_A EE_B Ty
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (nil Ty) nilVal [] @
============================
 evalExpr FE EE_B (nil Ty) nilVal []

 < search.

Subgoal 1.33:

Variables: FE EE_A O EE_B O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O @
EvA1 : evalExpr FE EE_A E1 V1 O2 *
EvA2 : evalExpr FE EE_A E2 V2 O3 *
EvA3 : O2 ++ O3 = O
============================
 evalExpr FE EE_B (cons E1 E2) (consVal V1 V2) O

 < case IsE.

Subgoal 1.33:

Variables: FE EE_A O EE_B O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O @
EvA1 : evalExpr FE EE_A E1 V1 O2 *
EvA2 : evalExpr FE EE_A E2 V2 O3 *
EvA3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 evalExpr FE EE_B (cons E1 E2) (consVal V1 V2) O

 < EvB1: apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.33:

Variables: FE EE_A O EE_B O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O @
EvA1 : evalExpr FE EE_A E1 V1 O2 *
EvA2 : evalExpr FE EE_A E2 V2 O3 *
EvA3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
EvB1 : evalExpr FE EE_B E1 V1 O2
============================
 evalExpr FE EE_B (cons E1 E2) (consVal V1 V2) O

 < EvB2: apply IH_E to _ _ _ _ SS EvA2.

Subgoal 1.33:

Variables: FE EE_A O EE_B O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (cons E1 E2) (consVal V1 V2) O @
EvA1 : evalExpr FE EE_A E1 V1 O2 *
EvA2 : evalExpr FE EE_A E2 V2 O3 *
EvA3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
EvB1 : evalExpr FE EE_B E1 V1 O2
EvB2 : evalExpr FE EE_B E2 V2 O3
============================
 evalExpr FE EE_B (cons E1 E2) (consVal V1 V2) O

 < search.

Subgoal 1.34:

Variables: FE EE_A V O EE_B Tl E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) V O @
EvA1 : evalExpr FE EE_A E1 (consVal V Tl) O *
============================
 evalExpr FE EE_B (head E1) V O

 < case IsE.

Subgoal 1.34:

Variables: FE EE_A V O EE_B Tl E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) V O @
EvA1 : evalExpr FE EE_A E1 (consVal V Tl) O *
H1 : is_expr E1
============================
 evalExpr FE EE_B (head E1) V O

 < EvB1: apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.34:

Variables: FE EE_A V O EE_B Tl E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (head E1) V O @
EvA1 : evalExpr FE EE_A E1 (consVal V Tl) O *
H1 : is_expr E1
EvB1 : evalExpr FE EE_B E1 (consVal V Tl) O
============================
 evalExpr FE EE_B (head E1) V O

 < search.

Subgoal 1.35:

Variables: FE EE_A V O EE_B Hd E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) V O @
EvA1 : evalExpr FE EE_A E1 (consVal Hd V) O *
============================
 evalExpr FE EE_B (tail E1) V O

 < case IsE.

Subgoal 1.35:

Variables: FE EE_A V O EE_B Hd E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) V O @
EvA1 : evalExpr FE EE_A E1 (consVal Hd V) O *
H1 : is_expr E1
============================
 evalExpr FE EE_B (tail E1) V O

 < EvB1: apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.35:

Variables: FE EE_A V O EE_B Hd E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (tail E1) V O @
EvA1 : evalExpr FE EE_A E1 (consVal Hd V) O *
H1 : is_expr E1
EvB1 : evalExpr FE EE_B E1 (consVal Hd V) O
============================
 evalExpr FE EE_B (tail E1) V O

 < search.

Subgoal 1.36:

Variables: FE EE_A O EE_B E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O @
EvA1 : evalExpr FE EE_A E1 nilVal O *
============================
 evalExpr FE EE_B (null E1) trueVal O

 < case IsE.

Subgoal 1.36:

Variables: FE EE_A O EE_B E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O @
EvA1 : evalExpr FE EE_A E1 nilVal O *
H1 : is_expr E1
============================
 evalExpr FE EE_B (null E1) trueVal O

 < EvB1: apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.36:

Variables: FE EE_A O EE_B E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) trueVal O @
EvA1 : evalExpr FE EE_A E1 nilVal O *
H1 : is_expr E1
EvB1 : evalExpr FE EE_B E1 nilVal O
============================
 evalExpr FE EE_B (null E1) trueVal O

 < search.

Subgoal 1.37:

Variables: FE EE_A O EE_B Hd Tl E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O @
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O *
============================
 evalExpr FE EE_B (null E1) falseVal O

 < case IsE.

Subgoal 1.37:

Variables: FE EE_A O EE_B Hd Tl E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O @
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O *
H1 : is_expr E1
============================
 evalExpr FE EE_B (null E1) falseVal O

 < EvB1: apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.37:

Variables: FE EE_A O EE_B Hd Tl E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (null E1) falseVal O @
EvA1 : evalExpr FE EE_A E1 (consVal Hd Tl) O *
H1 : is_expr E1
EvB1 : evalExpr FE EE_B E1 (consVal Hd Tl) O
============================
 evalExpr FE EE_B (null E1) falseVal O

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_A' O EE_B LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' O @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O2 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O3 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O2 ++ O3 = O
============================
 exists EE_B', evalStmt FE EE_B (listUpdate L I E) EE_B' O

 < case IsS.

Subgoal 2.15:

Variables: FE EE_A EE_A' O EE_B LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' O @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O2 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O3 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 exists EE_B', evalStmt FE EE_B (listUpdate L I E) EE_B' O

 < EvB1: apply IH_E to _ _ _ _ SS EvA2.

Subgoal 2.15:

Variables: FE EE_A EE_A' O EE_B LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' O @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O2 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O3 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB1 : evalExpr FE EE_B I VI O2
============================
 exists EE_B', evalStmt FE EE_B (listUpdate L I E) EE_B' O

 < EvB2: apply IH_E to _ _ _ _ SS EvA4.

Subgoal 2.15:

Variables: FE EE_A EE_A' O EE_B LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' O @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O2 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O3 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB1 : evalExpr FE EE_B I VI O2
EvB2 : evalExpr FE EE_B E V O3
============================
 exists EE_B', evalStmt FE EE_B (listUpdate L I E) EE_B' O

 < apply scopes_same_lookupScopes_exists to _ _ SS EvA1.

Subgoal 2.15:

Variables: FE EE_A EE_A' O EE_B LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' O @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O2 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O3 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB1 : evalExpr FE EE_B I VI O2
EvB2 : evalExpr FE EE_B E V O3
H4 : lookupScopes L EE_B LV
============================
 exists EE_B', evalStmt FE EE_B (listUpdate L I E) EE_B' O

 < apply scopes_same_replaceScopes_exists to _ _ _ SS EvA6.

Subgoal 2.15:

Variables: FE EE_A EE_A' O EE_B LV VI O2 N V O3 LV2 E I L B'
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listUpdate L I E) EE_A' O @
EvA1 : lookupScopes L EE_A LV
EvA2 : evalExpr FE EE_A I VI O2 *
EvA3 : matchInt VI N
EvA4 : evalExpr FE EE_A E V O3 *
EvA5 : updateListIndex LV N V LV2
EvA6 : replaceScopes L LV2 EE_A EE_A'
EvA7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
EvB1 : evalExpr FE EE_B I VI O2
EvB2 : evalExpr FE EE_B E V O3
H4 : lookupScopes L EE_B LV
H5 : replaceScopes L LV2 EE_B B'
============================
 exists EE_B', evalStmt FE EE_B (listUpdate L I E) EE_B' O

 < search.

Subgoal 2.16:

Variables: FE EE_A EE_A' O EE_B LV O2 O3 Body L X
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' O @
EvA1 : evalExpr FE EE_A L LV O2 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O3 *
EvA3 : O2 ++ O3 = O
============================
 exists EE_B', evalStmt FE EE_B (listForeach X L Body) EE_B' O

 < case IsS.

Subgoal 2.16:

Variables: FE EE_A EE_A' O EE_B LV O2 O3 Body L X
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' O @
EvA1 : evalExpr FE EE_A L LV O2 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O3 *
EvA3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 exists EE_B', evalStmt FE EE_B (listForeach X L Body) EE_B' O

 < apply IH_E to _ _ _ _ SS EvA1.

Subgoal 2.16:

Variables: FE EE_A EE_A' O EE_B LV O2 O3 Body L X
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' O @
EvA1 : evalExpr FE EE_A L LV O2 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O3 *
EvA3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : evalExpr FE EE_B L LV O2
============================
 exists EE_B', evalStmt FE EE_B (listForeach X L Body) EE_B' O

 < apply evalExpr_isValue to _ _ _ EvA1.

Subgoal 2.16:

Variables: FE EE_A EE_A' O EE_B LV O2 O3 Body L X
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' O @
EvA1 : evalExpr FE EE_A L LV O2 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O3 *
EvA3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : evalExpr FE EE_B L LV O2
H5 : is_value LV
============================
 exists EE_B', evalStmt FE EE_B (listForeach X L Body) EE_B' O

 < apply IH_IL to _ _ _ _ _ _ SS EvA2.

Subgoal 2.16:

Variables: FE EE_A EE_A' O EE_B LV O2 O3 Body L X EE_B'
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalStmt FE EE_A (listForeach X L Body) EE_A' O @
EvA1 : evalExpr FE EE_A L LV O2 *
EvA2 : iterateList FE EE_A LV X Body EE_A' O3 *
EvA3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : evalExpr FE EE_B L LV O2
H5 : is_value LV
H6 : iterateList FE EE_B LV X Body EE_B' O3
============================
 exists EE_B', evalStmt FE EE_B (listForeach X L Body) EE_B' O

 < search.

Subgoal 5.1:

Variables: X Body FE EE_A' EE_B
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A'
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A' EE_B
ILA : iterateList FE EE_A' nilVal X Body EE_A' [] @
============================
 exists EE_B', iterateList FE EE_B nilVal X Body EE_B' []

 < search.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < case IsV.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < SS1: assert scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B).

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < EvB: apply IH_S to _ _ _ _ SS1 ILA1.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd EE_B'
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body EE_B' O2
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < SS2: apply evalStmt_scopes_same_ctx to _ _ _ _ SS1 ILA1 EvB.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd EE_B'
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body EE_B' O2
SS2 : scopes_same (Scope::EE1) EE_B'
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < SS': case SS2.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd BRest B
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body (B::BRest) O2
SS' : forall X V, lookup Scope X V -> lookup B X V
SS'1 : forall X V, lookup B X V -> lookup Scope X V
SS'2 : scopes_same EE1 BRest
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < IsEE1+: apply evalStmt_isCtx to _ _ _ ILA1.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd BRest B
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body (B::BRest) O2
SS' : forall X V, lookup Scope X V -> lookup B X V
SS'1 : forall X V, lookup B X V -> lookup Scope X V
SS'2 : scopes_same EE1 BRest
IsEE1+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < case IsEE1+.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd BRest B
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body (B::BRest) O2
SS' : forall X V, lookup Scope X V -> lookup B X V
SS'1 : forall X V, lookup B X V -> lookup Scope X V
SS'2 : scopes_same EE1 BRest
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < IsBR+: apply evalStmt_isCtx to _ _ _ EvB.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd BRest B
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body (B::BRest) O2
SS' : forall X V, lookup Scope X V -> lookup B X V
SS'1 : forall X V, lookup B X V -> lookup Scope X V
SS'2 : scopes_same EE1 BRest
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
IsBR+ : is_list (is_list (is_pair is_string is_value)) (B::BRest)
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < case IsBR+.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd BRest B
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body (B::BRest) O2
SS' : forall X V, lookup Scope X V -> lookup B X V
SS'1 : forall X V, lookup B X V -> lookup Scope X V
SS'2 : scopes_same EE1 BRest
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) B
H6 : is_list (is_list (is_pair is_string is_value)) BRest
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < apply IH_IL to _ _ _ _ _ _ SS'2 ILA2.

Subgoal 5.2:

Variables: X Body FE EE_A EE_A' O EE_B Scope EE1 O2 O3 Tl Hd BRest B EE_B'1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IH_IL : forall V X Body FE EE_A EE_A' O EE_B,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> iterateList FE EE_A V X Body EE_A' O * -> exists EE_B',
            iterateList FE EE_B V X Body EE_B' O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
ILA : iterateList FE EE_A (consVal Hd Tl) X Body EE_A' O @
ILA1 : evalStmt FE ([(X, Hd)]::EE_A) Body (Scope::EE1) O2 *
ILA2 : iterateList FE EE1 Tl X Body EE_A' O3 *
ILA3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
SS1 : scopes_same ([(X, Hd)]::EE_A) ([(X, Hd)]::EE_B)
EvB : evalStmt FE ([(X, Hd)]::EE_B) Body (B::BRest) O2
SS' : forall X V, lookup Scope X V -> lookup B X V
SS'1 : forall X V, lookup B X V -> lookup Scope X V
SS'2 : scopes_same EE1 BRest
H3 : is_list (is_pair is_string is_value) Scope
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_pair is_string is_value) B
H6 : is_list (is_list (is_pair is_string is_value)) BRest
H7 : iterateList FE BRest Tl X Body EE_B'1 O3
============================
 exists EE_B', iterateList FE EE_B (consVal Hd Tl) X Body EE_B' O

 < search.

Proof completed.

 < Theorem is_list_values_append_nil :
     forall L, is_list is_value L -> L ++ [] = L.

============================
 forall L, is_list is_value L -> L ++ [] = L

 < induction on 1.

IH : forall L, is_list is_value L * -> L ++ [] = L
============================
 forall L, is_list is_value L @ -> L ++ [] = L

 < intros IsL.

Variables: L
IH : forall L, is_list is_value L * -> L ++ [] = L
IsL : is_list is_value L @
============================
 L ++ [] = L

 < Is: case IsL.

Subgoal 1:

IH : forall L, is_list is_value L * -> L ++ [] = L
============================
 [] ++ [] = []

 < search.

Subgoal 2:

Variables: T H
IH : forall L, is_list is_value L * -> L ++ [] = L
Is : is_value H
Is1 : is_list is_value T *
============================
 H::T ++ [] = H::T

 < apply IH to Is1.

Subgoal 2:

Variables: T H
IH : forall L, is_list is_value L * -> L ++ [] = L
Is : is_value H
Is1 : is_list is_value T *
H1 : T ++ [] = T
============================
 H::T ++ [] = H::T

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchInt.

Subgoal 1:

Variables: I
Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MI : matchInt (recVal [("null", trueVal)]) I
============================
 matchInt nilVal I

 < case MI.

Subgoal 2:

Variables: I V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MI : matchInt (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) I
============================
 matchInt (consVal V1 V2) I

 < case MI.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchTrue.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MT : matchTrue (recVal [("null", trueVal)])
============================
 matchTrue nilVal

 < case MT.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MT : matchTrue (recVal [("null", falseVal), ("head", V1), ("tail", V2)])
============================
 matchTrue (consVal V1 V2)

 < case MT.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchFalse.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MF : matchFalse (recVal [("null", trueVal)])
============================
 matchFalse nilVal

 < case MF.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MF : matchFalse (recVal [("null", falseVal), ("head", V1), ("tail", V2)])
============================
 matchFalse (consVal V1 V2)

 < case MF.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchString.

Subgoal 1:

Variables: S
Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MS : matchString (recVal [("null", trueVal)]) S
============================
 matchString nilVal S

 < case MS.

Subgoal 2:

Variables: S V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MS : matchString (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) S
============================
 matchString (consVal V1 V2) S

 < case MS.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchRec.

Subgoal 1:

Variables: Fs
Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MR : matchRec (recVal [("null", trueVal)]) Fs
============================
 matchRec nilVal Fs

 < MR: case MR.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
============================
 matchRec nilVal [("null", trueVal)]

 < search.

Subgoal 2:

Variables: Fs V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MR : matchRec (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) Fs
============================
 matchRec (consVal V1 V2) Fs

 < MR: case MR.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
============================
 matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)]

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchInt.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchInt.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.

 < Add_Proj_Rel matchEval:host:matchTrue.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchTrue.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.

 < Add_Proj_Rel matchEval:host:matchFalse.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchFalse.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.

 < Add_Proj_Rel matchEval:host:matchRec.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchRec.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 2:

IH : forall V Fs, matchRec V Fs * -> is_value V -> <matchRec {P}> V Fs
R : matchRec nilVal [("null", trueVal)] @
IsV : is_value nilVal
============================
 <matchRec {P}> nilVal [("null", trueVal)]

 < search.

Subgoal 3:

Variables: V2 V1
IH : forall V Fs, matchRec V Fs * -> is_value V -> <matchRec {P}> V Fs
R : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
IsV : is_value (consVal V1 V2)
============================
 <matchRec {P}> (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)]

 < case IsV.

Subgoal 3:

Variables: V2 V1
IH : forall V Fs, matchRec V Fs * -> is_value V -> <matchRec {P}> V Fs
R : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
H1 : is_value V1
H2 : is_value V2
============================
 <matchRec {P}> (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)]

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchString.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchString.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.

 < Prove matchEval:host:projedVal_is.

Proof completed.

 < Prove matchEval:host:projedVal_matchInt.

Proof completed.

 < Prove matchEval:host:projedVal_matchString.

Proof completed.

 < Prove matchEval:host:projedVal_matchTrue.

Proof completed.

 < Prove matchEval:host:projedVal_matchFalse.

Proof completed.

 < Prove matchEval:host:projedVal_matchRec.

Proof completed.

 < Prove_Constraint matchEval:host:matchInt_proj.

Subgoal 1:

Variables: I
Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MI : matchInt nilVal I
============================
 matchInt (recVal [("null", trueVal)]) I

 < case MI.

Subgoal 2:

Variables: I V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MI : matchInt (consVal V1 V2) I
============================
 matchInt (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) I

 < case MI.

Proof completed.

 < Prove_Constraint matchEval:host:matchTrue_proj.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MT : matchTrue nilVal
============================
 matchTrue (recVal [("null", trueVal)])

 < case MT.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MT : matchTrue (consVal V1 V2)
============================
 matchTrue (recVal [("null", falseVal), ("head", V1), ("tail", V2)])

 < case MT.

Proof completed.

 < Prove_Constraint matchEval:host:matchFalse_proj.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MF : matchFalse nilVal
============================
 matchFalse (recVal [("null", trueVal)])

 < case MF.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MF : matchFalse (consVal V1 V2)
============================
 matchFalse (recVal [("null", falseVal), ("head", V1), ("tail", V2)])

 < case MF.

Proof completed.

 < Prove_Constraint matchEval:host:matchString_proj.

Subgoal 1:

Variables: S
Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MS : matchString nilVal S
============================
 matchString (recVal [("null", trueVal)]) S

 < case MS.

Subgoal 2:

Variables: S V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MS : matchString (consVal V1 V2) S
============================
 matchString (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) S

 < case MS.

Proof completed.

 < Prove_Constraint matchEval:host:matchRec_proj.

Subgoal 1:

Variables: Fs
Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
MR : matchRec nilVal Fs
============================
 matchRec (recVal [("null", trueVal)]) Fs

 < MR: case MR.

Subgoal 1:

Pr : |{value}- nilVal ~~> recVal [("null", trueVal)]
IsV : is_value nilVal
============================
 matchRec (recVal [("null", trueVal)]) [("null", trueVal)]

 < search.

Subgoal 2:

Variables: Fs V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
MR : matchRec (consVal V1 V2) Fs
============================
 matchRec (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) Fs

 < MR: case MR.

Subgoal 2:

Variables: V2 V1
Pr : |{value}- consVal V1 V2 ~~> recVal [("null", falseVal), ("head", V1), ("tail", V2)]
IsV : is_value (consVal V1 V2)
============================
 matchRec (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) [("null", falseVal), ("head", V1), ("tail", V2)]

 < search.

Proof completed.

 < Prove matchEval:host:matchInt_projedVal.

Proof completed.

 < Prove matchEval:host:matchTrue_projedVal.

Proof completed.

 < Prove matchEval:host:matchFalse_projedVal.

Proof completed.

 < Prove matchEval:host:matchString_projedVal.

Proof completed.

 < Prove matchEval:host:matchRec_projedVal.

Proof completed.

 < Theorem projedFields_lookup_back :
     forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' -> exists V,
         lookup Fs X V /\ projedVal V V'.

============================
 forall Fs Fs' X V',
   projedFields Fs Fs' -> lookup Fs' X V' -> exists V,
     lookup Fs X V /\ projedVal V V'

 < induction on 2.

IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
============================
 forall Fs Fs' X V',
   projedFields Fs Fs' -> lookup Fs' X V' @ -> exists V,
     lookup Fs X V /\ projedVal V V'

 < intros PF L.

Variables: Fs Fs' X V'
IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
PF : projedFields Fs Fs'
L : lookup Fs' X V' @
============================
 exists V, lookup Fs X V /\ projedVal V V'

 < L: case L.

Subgoal 1:

Variables: Fs X V' Rest
IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
PF : projedFields Fs ((X, V')::Rest)
============================
 exists V, lookup Fs X V /\ projedVal V V'

 < case PF.

Subgoal 1:

Variables: X V' Rest ARest VA
IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
H1 : projedVal VA V'
H2 : projedFields ARest Rest
============================
 exists V, lookup ((X, VA)::ARest) X V /\ projedVal V V'

 < search.

Subgoal 2:

Variables: Fs X V' Rest V K
IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
PF : projedFields Fs ((K, V)::Rest)
L : K = X -> false
L1 : lookup Rest X V' *
============================
 exists V, lookup Fs X V /\ projedVal V V'

 < PF: case PF.

Subgoal 2:

Variables: X V' Rest V K ARest VA
IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
L : K = X -> false
L1 : lookup Rest X V' *
PF : projedVal VA V
PF1 : projedFields ARest Rest
============================
 exists V, lookup ((K, VA)::ARest) X V /\ projedVal V V'

 < apply IH to PF1 L1.

Subgoal 2:

Variables: X V' Rest V K ARest VA V1
IH : forall Fs Fs' X V',
       projedFields Fs Fs' -> lookup Fs' X V' * -> exists V,
         lookup Fs X V /\ projedVal V V'
L : K = X -> false
L1 : lookup Rest X V' *
PF : projedVal VA V
PF1 : projedFields ARest Rest
H1 : lookup ARest X V1
H2 : projedVal V1 V'
============================
 exists V, lookup ((K, VA)::ARest) X V /\ projedVal V V'

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalExpr_forward.

Subgoal 1:

Variables: FE EE V O Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (nil Ty) V O
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" true nilRecFieldExprs)) V' O /\
   projedVal V V'

 < case Ev.

Subgoal 1:

Variables: FE EE Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" true nilRecFieldExprs)) V' [] /\
   projedVal nilVal V'

 < apply scopes_same_reflexive to IsEE.

Subgoal 1:

Variables: FE EE Ty
Pr : |{expr}- nil Ty ~~> recBuild (consRecFieldExprs "null" true nilRecFieldExprs)
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
H1 : scopes_same EE EE
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" true nilRecFieldExprs)) V' [] /\
   projedVal nilVal V'

 < search.

Subgoal 2:

Variables: FE EE V O E2 E1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) V O
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V' O /\
   projedVal V V'

 < Ev: case Ev.

Subgoal 2:

Variables: FE EE O E2 E1 O2 O3 V2 V1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE E1 V1 O2
Ev1 : evalExpr FE EE E2 V2 O3
Ev2 : O2 ++ O3 = O
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V' O /\
   projedVal (consVal V1 V2) V'

 < case IsE.

Subgoal 2:

Variables: FE EE O E2 E1 O2 O3 V2 V1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE E1 V1 O2
Ev1 : evalExpr FE EE E2 V2 O3
Ev2 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V' O /\
   projedVal (consVal V1 V2) V'

 < IsO3: apply evalExpr_isOutput to _ _ _ Ev1.

Subgoal 2:

Variables: FE EE O E2 E1 O2 O3 V2 V1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE E1 V1 O2
Ev1 : evalExpr FE EE E2 V2 O3
Ev2 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
IsO3 : is_list is_value O3
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V' O /\
   projedVal (consVal V1 V2) V'

 < apply is_list_values_append_nil to IsO3.

Subgoal 2:

Variables: FE EE O E2 E1 O2 O3 V2 V1
Pr : |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE E1 V1 O2
Ev1 : evalExpr FE EE E2 V2 O3
Ev2 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
IsO3 : is_list is_value O3
H3 : O3 ++ [] = O3
============================
 exists V',
   evalExpr FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) V' O /\
   projedVal (consVal V1 V2) V'

 < search.

Subgoal 3:

Variables: FE EE V O E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) V O
============================
 exists V', evalExpr FE EE (recFieldAccess E1 "null") V' O /\ projedVal V V'

 < case IsE.

Subgoal 3:

Variables: FE EE V O E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) V O
H1 : is_expr E1
============================
 exists V', evalExpr FE EE (recFieldAccess E1 "null") V' O /\ projedVal V V'

 < Ev: case Ev.

Subgoal 3.1:

Variables: FE EE O E1
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
H1 : is_expr E1
Ev : evalExpr FE EE E1 nilVal O
============================
 exists V',
   evalExpr FE EE (recFieldAccess E1 "null") V' O /\ projedVal trueVal V'

 < search.

Subgoal 3.2:

Variables: FE EE O E1 Hd Tl
Pr : |{expr}- null E1 ~~> recFieldAccess E1 "null"
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
H1 : is_expr E1
Ev : evalExpr FE EE E1 (consVal Hd Tl) O
============================
 exists V',
   evalExpr FE EE (recFieldAccess E1 "null") V' O /\ projedVal falseVal V'

 < search.

Subgoal 4:

Variables: FE EE V O E1
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O
============================
 exists V', evalExpr FE EE (recFieldAccess E1 "head") V' O /\ projedVal V V'

 < Ev: case Ev.

Subgoal 4:

Variables: FE EE V O E1 Tl
Pr : |{expr}- head E1 ~~> recFieldAccess E1 "head"
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE E1 (consVal V Tl) O
============================
 exists V', evalExpr FE EE (recFieldAccess E1 "head") V' O /\ projedVal V V'

 < search.

Subgoal 5:

Variables: FE EE V O E1
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O
============================
 exists V', evalExpr FE EE (recFieldAccess E1 "tail") V' O /\ projedVal V V'

 < Ev: case Ev.

Subgoal 5:

Variables: FE EE V O E1 Hd
Pr : |{expr}- tail E1 ~~> recFieldAccess E1 "tail"
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE E1 (consVal Hd V) O
============================
 exists V', evalExpr FE EE (recFieldAccess E1 "tail") V' O /\ projedVal V V'

 < search.

Proof completed.

 < Extensible_Theorem
      iterateList_to_while : forall FE EE V X Body EE' O Names L,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsEE : is_list (is_list (is_pair is_string is_value)) EE ->
         IL : iterateList FE EE V X Body EE' O ->
         Names : names EE Names ->
         Fr : fresh_name "L" (X::Names) L ->
         exists V',
           evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
      on IL.

Subgoal 1:

Variables: FE X Body EE' Names L
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
IL : iterateList FE EE' nilVal X Body EE' [] @
Names : names EE' Names
Fr : fresh_name "L" (X::Names) L
============================
 exists V',
   evalStmt FE ([(L, nilVal)]::EE') (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') []

 < search 20.

Subgoal 2:

Variables: FE EE X Body EE' O Names L Scope EE3 O2 O3 Tl Hd
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < case IsV.

Subgoal 2:

Variables: FE EE X Body EE' O Names L Scope EE3 O2 O3 Tl Hd
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < IsEE''+: apply evalStmt_isCtx to _ _ _ IL1.

Subgoal 2:

Variables: FE EE X Body EE' O Names L Scope EE3 O2 O3 Tl Hd
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE''+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < IsEE'': case IsEE''+.

Subgoal 2:

Variables: FE EE X Body EE' O Names L Scope EE3 O2 O3 Tl Hd
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < NS: apply evalStmt_names_same to _ _ _ IL1.

Subgoal 2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE''
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < Names'': apply names_exists to IsEE''1.

Subgoal 2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < IsN: apply names_is to _ Names''.

Subgoal 2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < Fr': apply fresh_name_exists to _ _ with
          Base = "L" Names = X::N.

Subgoal 2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
============================
 exists V',
   evalStmt FE ([(L, consVal Hd Tl)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O

 < apply fresh_name_unique_mems to Fr Fr' _ _.

Subgoal 2.1:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
============================
 forall X1, mem X1 (X::N) -> mem X1 (X::Names)

 < intros M.

Subgoal 2.1:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 (X::N)
============================
 mem X1 (X::Names)

 < M: case M.

Subgoal 2.1.1:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
============================
 mem X (X::Names)

 < search.

Subgoal 2.1.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 N
============================
 mem X1 (X::Names)

 < NS': apply names_same_symmetric to NS.

Subgoal 2.1.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 N
NS' : names_same EE'' EE
============================
 mem X1 (X::Names)

 < apply names_same_names to NS' Names'' Names M.

Subgoal 2.1.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 N
NS' : names_same EE'' EE
H3 : mem X1 Names
============================
 mem X1 (X::Names)

 < search.

Subgoal 2.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
============================
 forall X1, mem X1 (X::Names) -> mem X1 (X::N)

 < intros M.

Subgoal 2.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 (X::Names)
============================
 mem X1 (X::N)

 < M: case M.

Subgoal 2.2.1:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
============================
 mem X (X::N)

 < search.

Subgoal 2.2.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 Names
============================
 mem X1 (X::N)

 < apply names_same_names to NS Names Names'' M.

Subgoal 2.2.2:

Variables: FE EE X Body EE' O Names L O2 O3 Tl Hd Scope' EE'' N F X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) L
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
M : mem X1 Names
H3 : mem X1 N
============================
 mem X1 (X::N)

 < search.

Subgoal 2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
============================
 exists V',
   evalStmt FE ([(F, consVal Hd Tl)]::EE) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O

 < EvSub: apply IH to _ _ _ _ _ IL2 Names'' Fr'.

Subgoal 2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 exists V',
   evalStmt FE ([(F, consVal Hd Tl)]::EE) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O

 < exists V'.

Subgoal 2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalStmt FE ([(F, consVal Hd Tl)]::EE) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O

 < unfold .

Subgoal 2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 exists V O1 Scope EE1 O2 O3 O12,
   evalExpr FE ([(F, consVal Hd Tl)]::EE) (not (null (name F))) V O1 /\
   (matchTrue V /\
   (evalStmt FE ([]::([(F, consVal Hd Tl)]::EE)) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body)) (Scope::EE1) O2 /\
   (evalStmt FE EE1 (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3 /\
   (O1 ++ O2 = O12 /\ O12 ++ O3 = O))))

 < exists trueVal,
   [],
   Scope',
   [(F, Tl)]::EE'',
   O2,
   O3,
   O2.

Subgoal 2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalExpr FE ([(F, consVal Hd Tl)]::EE) (not (null (name F))) trueVal [] /\
 (matchTrue trueVal /\
 (evalStmt FE ([]::([(F, consVal Hd Tl)]::EE)) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body)) (Scope'::([(F, Tl)]::EE'')) O2 /\
 (evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3 /\
 ([] ++ O2 = O2 /\ O2 ++ O3 = O))))

 < split.

Subgoal 2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalExpr FE ([(F, consVal Hd Tl)]::EE) (not (null (name F))) trueVal []

 < search.

Subgoal 2.4:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 matchTrue trueVal

 < search.

Subgoal 2.5:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalStmt FE ([]::([(F, consVal Hd Tl)]::EE)) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body)) (Scope'::([(F, Tl)]::EE'')) O2

 < unfold .

Subgoal 2.5:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 exists EE1 O1 O3,
   evalStmt FE ([]::([(F, consVal Hd Tl)]::EE)) (declare intTy X (head (name F))) EE1 O1 /\
   (evalStmt FE EE1 (seq (assign F (tail (name F))) Body) (Scope'::([(F, Tl)]::EE'')) O3 /\
   O1 ++ O3 = O2)

 < exists [(X, Hd)]::([(F, consVal Hd Tl)]::EE),
   [],
   O2.

Subgoal 2.5:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalStmt FE ([]::([(F, consVal Hd Tl)]::EE)) (declare intTy X (head (name F))) ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) [] /\
 (evalStmt FE ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) (seq (assign F (tail (name F))) Body) (Scope'::([(F, Tl)]::EE'')) O2 /\
 [] ++ O2 = O2)

 < split.

Subgoal 2.5.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalStmt FE ([]::([(F, consVal Hd Tl)]::EE)) (declare intTy X (head (name F))) ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) []

 < search 20.

Subgoal 2.5.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalStmt FE ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) (seq (assign F (tail (name F))) Body) (Scope'::([(F, Tl)]::EE'')) O2

 < NEq: assert X = F -> false.

Subgoal 2.5.2.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 X = F -> false

 < intros E.

Subgoal 2.5.2.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
E : X = F
============================
 false

 < case E.

Subgoal 2.5.2.1:

Variables: FE EE Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string F
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) F Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (F::Names) F
IL1 : evalStmt FE ([(F, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl F Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (F::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy F (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 false

 < apply fresh_name_not_mem to Fr _.

Subgoal 2.5.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
============================
 evalStmt FE ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) (seq (assign F (tail (name F))) Body) (Scope'::([(F, Tl)]::EE'')) O2

 < unfold .

Subgoal 2.5.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
============================
 exists EE1 O1 O3,
   evalStmt FE ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) (assign F (tail (name F))) EE1 O1 /\
   (evalStmt FE EE1 Body (Scope'::([(F, Tl)]::EE'')) O3 /\ O1 ++ O3 = O2)

 < exists [(X, Hd)]::([(F, Tl)]::EE),
   [],
   O2.

Subgoal 2.5.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
============================
 evalStmt FE ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) (assign F (tail (name F))) ([(X, Hd)]::([(F, Tl)]::EE)) [] /\
 (evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2 /\
 [] ++ O2 = O2)

 < split.

Subgoal 2.5.2.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
============================
 evalStmt FE ([(X, Hd)]::([(F, consVal Hd Tl)]::EE)) (assign F (tail (name F))) ([(X, Hd)]::([(F, Tl)]::EE)) []

 < search 10.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < LenEE: apply length_exists_list_pair_string_value to IsEE.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' N1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE N1
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < rename N1 to Len.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < NNS: assert newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE.

Subgoal 2.5.2.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE

 < unfold .

Subgoal 2.5.2.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 exists N SNames BNames,
   ((((length EE Len /\ drop N ([(F, Tl)]::EE) EE) /\
   take N ([(F, Tl)]::EE) [[(F, Tl)]]) /\
   names [[(F, Tl)]] SNames) /\
   names EE BNames) /\
   (forall X, mem X SNames -> mem X BNames -> false)

 < exists 1,
   [F],
   Names.

Subgoal 2.5.2.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 ((((length EE Len /\ drop 1 ([(F, Tl)]::EE) EE) /\
 take 1 ([(F, Tl)]::EE) [[(F, Tl)]]) /\
 names [[(F, Tl)]] [F]) /\
 names EE Names) /\
 (forall X, mem X [F] -> mem X Names -> false)

 < split.

Subgoal 2.5.2.3.1.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 length EE Len

 < search.

Subgoal 2.5.2.3.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 drop 1 ([(F, Tl)]::EE) EE

 < search.

Subgoal 2.5.2.3.1.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 take 1 ([(F, Tl)]::EE) [[(F, Tl)]]

 < search.

Subgoal 2.5.2.3.1.4:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 names [[(F, Tl)]] [F]

 < search.

Subgoal 2.5.2.3.1.5:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 names EE Names

 < search.

Subgoal 2.5.2.3.1.6:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
============================
 forall X, mem X [F] -> mem X Names -> false

 < intros M MN.

Subgoal 2.5.2.3.1.6:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
M : mem X1 [F]
MN : mem X1 Names
============================
 false

 < M: case M.

Subgoal 2.5.2.3.1.6.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
MN : mem F Names
============================
 false

 < apply fresh_name_not_mem to Fr _.

Subgoal 2.5.2.3.1.6.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
MN : mem X1 Names
M : mem X1 []
============================
 false

 < case M.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply fresh_name_is to _ Fr.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Ev: apply evalStmt_newNameScopes_exists to _ _ _ _ IL1 NNS.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len EE_A'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body EE_A' O2
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < NNS': apply evalStmt_newNameScopes to _ _ _ _ Ev IL1 _.

Subgoal 2.5.2.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len EE_A'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body EE_A' O2
NNS' : newNameScopes [[(F, Tl)]] Len EE_A' (Scope'::EE'')
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < NNS': case NNS'.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len EE_A' N1 SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body EE_A' O2
NNS' : length (Scope'::EE'') Len
NNS'1 : drop N1 EE_A' (Scope'::EE'')
NNS'2 : take N1 EE_A' [[(F, Tl)]]
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Take: case NNS'2.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len N1 SNames BNames N2 L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'1 : drop N1 ([(F, Tl)]::L1) (Scope'::EE'')
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + N2 = N1
Take1 : take N2 L1 []
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < case Take1.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len N1 SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'1 : drop N1 ([(F, Tl)]::L1) (Scope'::EE'')
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = N1
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < compute Take.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'1 : drop 1 ([(F, Tl)]::L1) (Scope'::EE'')
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Drop: case NNS'1.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1 N3
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N3 = 1
Drop1 : drop N3 L1 (Scope'::EE'')
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply drop_is_integer to Drop1.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1 N3
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N3 = 1
Drop1 : drop N3 L1 (Scope'::EE'')
H4 : is_integer N3
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply plus_integer_unique_addend to _ _ _ Take Drop.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 (Scope'::EE'')
H4 : is_integer 0
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Eq: assert L1 = Scope'::EE''.

Subgoal 2.5.2.3.2.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 (Scope'::EE'')
H4 : is_integer 0
============================
 L1 = Scope'::EE''

 < D: case Drop1.

Subgoal 2.5.2.3.2.1.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
============================
 Scope'::EE'' = Scope'::EE''

 < search.

Subgoal 2.5.2.3.2.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N4 L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(X1::L2)) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + N4 = 0
D1 : drop N4 L2 (Scope'::EE'')
============================
 X1::L2 = Scope'::EE''

 < apply drop_is_integer to D1.

Subgoal 2.5.2.3.2.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N4 L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(X1::L2)) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + N4 = 0
D1 : drop N4 L2 (Scope'::EE'')
H5 : is_integer N4
============================
 X1::L2 = Scope'::EE''

 < P: assert 1 + -1 = 0.

Subgoal 2.5.2.3.2.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N4 L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(X1::L2)) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + N4 = 0
D1 : drop N4 L2 (Scope'::EE'')
H5 : is_integer N4
P : 1 + -1 = 0
============================
 X1::L2 = Scope'::EE''

 < apply plus_integer_unique_addend to _ _ _ P D.

Subgoal 2.5.2.3.2.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(X1::L2)) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 (Scope'::EE'')
H5 : is_integer -1
P : 1 + -1 = 0
============================
 X1::L2 = Scope'::EE''

 < GEq: apply drop_geq_0 to D1.

Subgoal 2.5.2.3.2.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(X1::L2)) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 (Scope'::EE'')
H5 : is_integer -1
P : 1 + -1 = 0
GEq : -1 >= 0
============================
 X1::L2 = Scope'::EE''

 < LEq: case GEq.

Subgoal 2.5.2.3.2.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(X1::L2)) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 (Scope'::EE'')
H5 : is_integer -1
P : 1 + -1 = 0
LEq : 0 <= -1
============================
 X1::L2 = Scope'::EE''

 < case LEq.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::L1) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 (Scope'::EE'')
H4 : is_integer 0
Eq : L1 = Scope'::EE''
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < case Eq.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 (Scope'::EE'') (Scope'::EE'')
H4 : is_integer 0
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < clear Take
   Drop
   Drop1.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS' : length (Scope'::EE'') Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
H4 : is_integer 0
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Len: case NNS'.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
H4 : is_integer 0
Len : length EE'' N'
Len1 : 1 + N' = Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply length_is to Len.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
H4 : is_integer 0
Len : length EE'' N'
Len1 : 1 + N' = Len
H5 : is_integer N'
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < L: apply lt_plus_one to Len1 _.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
H4 : is_integer 0
Len : length EE'' N'
Len1 : 1 + N' = Len
H5 : is_integer N'
L : N' < Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Len'': apply names_same_length to NS LenEE.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
H4 : is_integer 0
Len : length EE'' N'
Len1 : 1 + N' = Len
H5 : is_integer N'
L : N' < Len
Len'' : length EE'' Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply length_unique to Len'' Len.

Subgoal 2.5.2.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' SNames BNames N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE N'
NNS : newNameScopes [[(F, Tl)]] N' ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body ([(F, Tl)]::(Scope'::EE'')) O2
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names (Scope'::EE'') BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
H4 : is_integer 0
Len : length EE'' N'
Len1 : 1 + N' = N'
H5 : is_integer N'
L : N' < N'
Len'' : length EE'' N'
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply less_integer_not_eq to L.

Subgoal 2.5.2.3.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len AR
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::AR) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR EE''
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < NNS': case NNS'.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len AR N1 SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::AR) O2
NNS' : length EE'' Len
NNS'1 : drop N1 AR EE''
NNS'2 : take N1 AR [[(F, Tl)]]
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Take: case NNS'2.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len N1 SNames BNames N2 L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'1 : drop N1 ([(F, Tl)]::L1) EE''
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + N2 = N1
Take1 : take N2 L1 []
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < case Take1.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len N1 SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'1 : drop N1 ([(F, Tl)]::L1) EE''
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = N1
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < compute Take.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'1 : drop 1 ([(F, Tl)]::L1) EE''
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Drop: case NNS'1.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1 N3
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N3 = 1
Drop1 : drop N3 L1 EE''
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply drop_is_integer to Drop1.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1 N3
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N3 = 1
Drop1 : drop N3 L1 EE''
H4 : is_integer N3
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < apply plus_integer_unique_addend to _ _ _ Take Drop.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 EE''
H4 : is_integer 0
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < Eq: assert L1 = EE''.

Subgoal 2.5.2.3.3.1.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 EE''
H4 : is_integer 0
============================
 L1 = EE''

 < D: case Drop1.

Subgoal 2.5.2.3.3.1.1.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
============================
 EE'' = EE''

 < search.

Subgoal 2.5.2.3.3.1.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N4 L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(X1::L2))) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + N4 = 0
D1 : drop N4 L2 EE''
============================
 X1::L2 = EE''

 < P: assert 1 + -1 = 0.

Subgoal 2.5.2.3.3.1.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N4 L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(X1::L2))) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + N4 = 0
D1 : drop N4 L2 EE''
P : 1 + -1 = 0
============================
 X1::L2 = EE''

 < apply drop_is_integer to D1.

Subgoal 2.5.2.3.3.1.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames N4 L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(X1::L2))) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + N4 = 0
D1 : drop N4 L2 EE''
P : 1 + -1 = 0
H5 : is_integer N4
============================
 X1::L2 = EE''

 < apply plus_integer_unique_addend to _ _ _ D P.

Subgoal 2.5.2.3.3.1.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(X1::L2))) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 EE''
P : 1 + -1 = 0
H5 : is_integer -1
============================
 X1::L2 = EE''

 < GEq: apply drop_geq_0 to D1.

Subgoal 2.5.2.3.3.1.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(X1::L2))) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 EE''
P : 1 + -1 = 0
H5 : is_integer -1
GEq : -1 >= 0
============================
 X1::L2 = EE''

 < LEq: case GEq.

Subgoal 2.5.2.3.3.1.1.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L2 X1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(X1::L2))) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H4 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 EE''
P : 1 + -1 = 0
H5 : is_integer -1
LEq : 0 <= -1
============================
 X1::L2 = EE''

 < case LEq.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames L1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::L1)) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 EE''
H4 : is_integer 0
Eq : L1 = EE''
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < case Eq.

Subgoal 2.5.2.3.3.1:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V' Len SNames BNames
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2
NNS' : length EE'' Len
NNS'3 : names [[(F, Tl)]] SNames
NNS'4 : names EE'' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 EE'' EE''
H4 : is_integer 0
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::EE'')) O2

 < search.

Subgoal 2.5.2.3.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' N F V' Len BR S AR1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::(S::BR)) O2 *
IL2 : iterateList FE (S::BR) Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) (S::BR)
NS : names_same EE (S::BR)
Names'' : names (S::BR) N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::(S::BR)) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::(S::AR1)) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR1 BR
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(S::BR))) O2

 < LenBR+: apply names_same_length to NS LenEE.

Subgoal 2.5.2.3.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' N F V' Len BR S AR1
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::(S::BR)) O2 *
IL2 : iterateList FE (S::BR) Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) (S::BR)
NS : names_same EE (S::BR)
Names'' : names (S::BR) N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::(S::BR)) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::(S::AR1)) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR1 BR
LenBR+ : length (S::BR) Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(S::BR))) O2

 < LenBR: case LenBR+.

Subgoal 2.5.2.3.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' N F V' Len BR S AR1 N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::(S::BR)) O2 *
IL2 : iterateList FE (S::BR) Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) (S::BR)
NS : names_same EE (S::BR)
Names'' : names (S::BR) N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::(S::BR)) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::(S::AR1)) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR1 BR
LenBR : length BR N'
LenBR1 : 1 + N' = Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(S::BR))) O2

 < apply length_is to LenBR.

Subgoal 2.5.2.3.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' N F V' Len BR S AR1 N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::(S::BR)) O2 *
IL2 : iterateList FE (S::BR) Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) (S::BR)
NS : names_same EE (S::BR)
Names'' : names (S::BR) N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::(S::BR)) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::(S::AR1)) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR1 BR
LenBR : length BR N'
LenBR1 : 1 + N' = Len
H4 : is_integer N'
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(S::BR))) O2

 < L: apply lt_plus_one to LenBR1 _.

Subgoal 2.5.2.3.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' N F V' Len BR S AR1 N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::(S::BR)) O2 *
IL2 : iterateList FE (S::BR) Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) (S::BR)
NS : names_same EE (S::BR)
Names'' : names (S::BR) N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::(S::BR)) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::(S::AR1)) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR1 BR
LenBR : length BR N'
LenBR1 : 1 + N' = Len
H4 : is_integer N'
L : N' < Len
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(S::BR))) O2

 < LEq: apply newNameScopes_length to NNS' LenBR.

Subgoal 2.5.2.3.3.2:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' N F V' Len BR S AR1 N'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::(S::BR)) O2 *
IL2 : iterateList FE (S::BR) Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) (S::BR)
NS : names_same EE (S::BR)
Names'' : names (S::BR) N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::(S::BR)) (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
LenEE : length EE Len
NNS : newNameScopes [[(F, Tl)]] Len ([(F, Tl)]::EE) EE
H3 : is_string F
Ev : evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::(S::AR1)) O2
NNS' : newNameScopes [[(F, Tl)]] Len AR1 BR
LenBR : length BR N'
LenBR1 : 1 + N' = Len
H4 : is_integer N'
L : N' < Len
LEq : Len <= N'
============================
 evalStmt FE ([(X, Hd)]::([(F, Tl)]::EE)) Body (Scope'::([(F, Tl)]::(S::BR))) O2

 < apply less_lesseq_flip_false to L LEq.

Subgoal 2.5.2.4:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
NEq : X = F -> false
============================
 [] ++ O2 = O2

 < search.

Subgoal 2.5.3:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 [] ++ O2 = O2

 < search.

Subgoal 2.6:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3

 < search.

Subgoal 2.7:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 [] ++ O2 = O2

 < search.

Subgoal 2.8:

Variables: FE EE X Body EE' O Names O2 O3 Tl Hd Scope' EE'' N F V'
IH : forall FE EE V X Body EE' O Names L,
       is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
       names EE Names -> fresh_name "L" (X::Names) L -> exists V',
         evalStmt FE ([(L, V)]::EE) (while (not (null (name L))) (seq (declare intTy X (head (name L))) (seq (assign L (tail (name L))) Body))) ([(L, V')]::EE') O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Names : names EE Names
Fr : fresh_name "L" (X::Names) F
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 *
IL2 : iterateList FE EE'' Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
IsEE'' : is_list (is_pair is_string is_value) Scope'
IsEE''1 : is_list (is_list (is_pair is_string is_value)) EE''
NS : names_same EE EE''
Names'' : names EE'' N
IsN : is_list is_string N
Fr' : fresh_name "L" (X::N) F
EvSub : evalStmt FE ([(F, Tl)]::EE'') (while (not (null (name F))) (seq (declare intTy X (head (name F))) (seq (assign F (tail (name F))) Body))) ([(F, V')]::EE') O3
============================
 O2 ++ O3 = O

 < search.

Proof completed.

 < Theorem lookupScopes_replaceScopes_exists :
     forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V ->
       exists R, replaceScopes Key V' L R.

============================
 forall L Key V V',
   is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V ->
   exists R, replaceScopes Key V' L R

 < induction on 3.

IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
============================
 forall L Key V V',
   is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V @ ->
   exists R, replaceScopes Key V' L R

 < intros IsL IsKey LS.

Variables: L Key V V'
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsL : is_list (is_list (is_pair is_string is_value)) L
IsKey : is_string Key
LS : lookupScopes Key L V @
============================
 exists R, replaceScopes Key V' L R

 < LS: case LS.

Subgoal 1:

Variables: Key V V' Rest L1
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsL : is_list (is_list (is_pair is_string is_value)) (L1::Rest)
IsKey : is_string Key
LS : lookup L1 Key V
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < Is: case IsL.

Subgoal 1:

Variables: Key V V' Rest L1
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsKey : is_string Key
LS : lookup L1 Key V
Is : is_list (is_pair is_string is_value) L1
Is1 : is_list (is_list (is_pair is_string is_value)) Rest
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < RA: apply remove_all_exists to Is IsKey.

Subgoal 1:

Variables: Key V V' Rest L1 EE'
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsKey : is_string Key
LS : lookup L1 Key V
Is : is_list (is_pair is_string is_value) L1
Is1 : is_list (is_list (is_pair is_string is_value)) Rest
RA : remove_all L1 Key EE'
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < M: apply lookup_mem to LS.

Subgoal 1:

Variables: Key V V' Rest L1 EE'
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsKey : is_string Key
LS : lookup L1 Key V
Is : is_list (is_pair is_string is_value) L1
Is1 : is_list (is_list (is_pair is_string is_value)) Rest
RA : remove_all L1 Key EE'
M : mem (Key, V) L1
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < search.

Subgoal 2:

Variables: Key V V' Rest L1
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsL : is_list (is_list (is_pair is_string is_value)) (L1::Rest)
IsKey : is_string Key
LS : no_lookup L1 Key
LS1 : lookupScopes Key Rest V *
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < case IsL.

Subgoal 2:

Variables: Key V V' Rest L1
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsKey : is_string Key
LS : no_lookup L1 Key
LS1 : lookupScopes Key Rest V *
H1 : is_list (is_pair is_string is_value) L1
H2 : is_list (is_list (is_pair is_string is_value)) Rest
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < apply IH to _ _ LS1 with
     V' = V'.

Subgoal 2:

Variables: Key V V' Rest L1 R
IH : forall L Key V V',
       is_list (is_list (is_pair is_string is_value)) L -> is_string Key -> lookupScopes Key L V * ->
       exists R, replaceScopes Key V' L R
IsKey : is_string Key
LS : no_lookup L1 Key
LS1 : lookupScopes Key Rest V *
H1 : is_list (is_pair is_string is_value) L1
H2 : is_list (is_list (is_pair is_string is_value)) Rest
H3 : replaceScopes Key V' Rest R
============================
 exists R, replaceScopes Key V' (L1::Rest) R

 < search.

Proof completed.

 < Theorem replaceScopes_lookupScopes_same  [Key, Item] :
     forall L (Key : Key) (V : Item) R,
       replaceScopes Key V L R -> lookupScopes Key R V.

============================
 forall L Key V R, replaceScopes Key V L R -> lookupScopes Key R V

 < induction on 1.

IH : forall L Key V R, replaceScopes Key V L R * -> lookupScopes Key R V
============================
 forall L Key V R, replaceScopes Key V L R @ -> lookupScopes Key R V

 < intros RS.

Variables: L Key V R
IH : forall L Key V R, replaceScopes Key V L R * -> lookupScopes Key R V
RS : replaceScopes Key V L R @
============================
 lookupScopes Key R V

 < RS: case RS.

Subgoal 1:

Variables: Key V I Rest LRemain L1
IH : forall L Key V R, replaceScopes Key V L R * -> lookupScopes Key R V
RS : mem (Key, I) L1
RS1 : remove_all L1 Key LRemain
============================
 lookupScopes Key (((Key, V)::LRemain)::Rest) V

 < search.

Subgoal 2:

Variables: Key V New L1 Rest
IH : forall L Key V R, replaceScopes Key V L R * -> lookupScopes Key R V
RS : no_lookup L1 Key
RS1 : replaceScopes Key V Rest New *
============================
 lookupScopes Key (L1::New) V

 < apply IH to RS1.

Subgoal 2:

Variables: Key V New L1 Rest
IH : forall L Key V R, replaceScopes Key V L R * -> lookupScopes Key R V
RS : no_lookup L1 Key
RS1 : replaceScopes Key V Rest New *
H1 : lookupScopes Key New V
============================
 lookupScopes Key (L1::New) V

 < search.

Proof completed.

 < Theorem remove_all_twice  [K, V] :
     forall (L : list (pair K V)) K RA RB,
       remove_all L K RA -> remove_all RA K RB -> RA = RB.

============================
 forall L K RA RB, remove_all L K RA -> remove_all RA K RB -> RA = RB

 < induction on 1.

IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
============================
 forall L K RA RB, remove_all L K RA @ -> remove_all RA K RB -> RA = RB

 < intros RA RB.

Variables: L K RA RB
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RA : remove_all L K RA @
RB : remove_all RA K RB
============================
 RA = RB

 < RA: case RA.

Subgoal 1:

Variables: K RB
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RB : remove_all [] K RB
============================
 [] = RB

 < case RB.

Subgoal 1:

Variables: K
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
============================
 [] = []

 < search.

Subgoal 2:

Variables: K RA RB Rest Item
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RB : remove_all RA K RB
RA : remove_all Rest K RA *
============================
 RA = RB

 < apply IH to RA RB.

Subgoal 2:

Variables: K RB Rest Item
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RB : remove_all RB K RB
RA : remove_all Rest K RB *
============================
 RB = RB

 < search.

Subgoal 3:

Variables: K RB R Item K1 Rest
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RB : remove_all ((K1, Item)::R) K RB
RA : K1 = K -> false
RA1 : remove_all Rest K R *
============================
 (K1, Item)::R = RB

 < RB: case RB.

Subgoal 3.1:

Variables: K RB R Item Rest
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RA : K = K -> false
RA1 : remove_all Rest K R *
RB : remove_all R K RB
============================
 (K, Item)::R = RB

 < apply RA to _.

Subgoal 3.2:

Variables: K R Item K1 Rest R1
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RA : K1 = K -> false
RA1 : remove_all Rest K R *
RB : K1 = K -> false
RB1 : remove_all R K R1
============================
 (K1, Item)::R = (K1, Item)::R1

 < apply IH to RA1 RB1.

Subgoal 3.2:

Variables: K Item K1 Rest R1
IH : forall L K RA RB, remove_all L K RA * -> remove_all RA K RB -> RA = RB
RA : K1 = K -> false
RA1 : remove_all Rest K R1 *
RB : K1 = K -> false
RB1 : remove_all R1 K R1
============================
 (K1, Item)::R1 = (K1, Item)::R1

 < search.

Proof completed.

 < Theorem replaceScopes_twice  [Key, Item] :
     forall (L : list (list (pair (string) value))) K VA RA VB RB,
       replaceScopes K VA L RA -> replaceScopes K VB RA RB -> replaceScopes K VB L RB.

============================
 forall L K VA RA VB RB,
   replaceScopes K VA L RA -> replaceScopes K VB RA RB -> replaceScopes K VB L RB

 < induction on 1.

IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
============================
 forall L K VA RA VB RB,
   replaceScopes K VA L RA @ -> replaceScopes K VB RA RB -> replaceScopes K VB L RB

 < intros RSA RSB.

Variables: L K VA RA VB RB
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : replaceScopes K VA L RA @
RSB : replaceScopes K VB RA RB
============================
 replaceScopes K VB L RB

 < RSA: case RSA.

Subgoal 1:

Variables: K VA VB RB I Rest LRemain L1
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSB : replaceScopes K VB (((K, VA)::LRemain)::Rest) RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain
============================
 replaceScopes K VB (L1::Rest) RB

 < RSB: case RSB.

Subgoal 1.1:

Variables: K VA VB I Rest LRemain L1 I1 LRemain1
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain
RSB : mem (K, I1) ((K, VA)::LRemain)
RSB1 : remove_all ((K, VA)::LRemain) K LRemain1
============================
 replaceScopes K VB (L1::Rest) (((K, VB)::LRemain1)::Rest)

 < RA: case RSB1.

Subgoal 1.1.1:

Variables: K VA VB I Rest LRemain L1 I1 LRemain1
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain
RSB : mem (K, I1) ((K, VA)::LRemain)
RA : remove_all LRemain K LRemain1
============================
 replaceScopes K VB (L1::Rest) (((K, VB)::LRemain1)::Rest)

 < apply remove_all_twice to RSA1 RA.

Subgoal 1.1.1:

Variables: K VA VB I Rest L1 I1 LRemain1
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain1
RSB : mem (K, I1) ((K, VA)::LRemain1)
RA : remove_all LRemain1 K LRemain1
============================
 replaceScopes K VB (L1::Rest) (((K, VB)::LRemain1)::Rest)

 < search.

Subgoal 1.1.2:

Variables: K VA VB I Rest LRemain L1 I1 R
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain
RSB : mem (K, I1) ((K, VA)::LRemain)
RA : K = K -> false
RA1 : remove_all LRemain K R
============================
 replaceScopes K VB (L1::Rest) (((K, VB)::((K, VA)::R))::Rest)

 < apply RA to _.

Subgoal 1.2:

Variables: K VA VB I Rest LRemain L1 New
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain
RSB : no_lookup ((K, VA)::LRemain) K
RSB1 : replaceScopes K VB Rest New
============================
 replaceScopes K VB (L1::Rest) (((K, VA)::LRemain)::New)

 < N: case RSB.

Subgoal 1.2:

Variables: K VA VB I Rest LRemain L1 New
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : mem (K, I) L1
RSA1 : remove_all L1 K LRemain
RSB1 : replaceScopes K VB Rest New
N : K = K -> false
N1 : no_lookup LRemain K
============================
 replaceScopes K VB (L1::Rest) (((K, VA)::LRemain)::New)

 < apply N to _.

Subgoal 2:

Variables: K VA VB RB New L1 Rest
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSB : replaceScopes K VB (L1::New) RB
RSA : no_lookup L1 K
RSA1 : replaceScopes K VA Rest New *
============================
 replaceScopes K VB (L1::Rest) RB

 < RSB: case RSB.

Subgoal 2.1:

Variables: K VA VB New L1 Rest I LRemain
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : no_lookup L1 K
RSA1 : replaceScopes K VA Rest New *
RSB : mem (K, I) L1
RSB1 : remove_all L1 K LRemain
============================
 replaceScopes K VB (L1::Rest) (((K, VB)::LRemain)::New)

 < apply no_lookup_mem to RSA RSB.

Subgoal 2.2:

Variables: K VA VB New L1 Rest New1
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : no_lookup L1 K
RSA1 : replaceScopes K VA Rest New *
RSB : no_lookup L1 K
RSB1 : replaceScopes K VB New New1
============================
 replaceScopes K VB (L1::Rest) (L1::New1)

 < apply IH to RSA1 RSB1.

Subgoal 2.2:

Variables: K VA VB New L1 Rest New1
IH : forall L K VA RA VB RB,
       replaceScopes K VA L RA * -> replaceScopes K VB RA RB -> replaceScopes K VB L RB
RSA : no_lookup L1 K
RSA1 : replaceScopes K VA Rest New *
RSB : no_lookup L1 K
RSB1 : replaceScopes K VB New New1
H1 : replaceScopes K VB Rest New1
============================
 replaceScopes K VB (L1::Rest) (L1::New1)

 < search.

Proof completed.

 < Theorem updateListIndex_is_integer :
     forall L I V L', updateListIndex L I V L' -> is_integer I.

============================
 forall L I V L', updateListIndex L I V L' -> is_integer I

 < induction on 1.

IH : forall L I V L', updateListIndex L I V L' * -> is_integer I
============================
 forall L I V L', updateListIndex L I V L' @ -> is_integer I

 < intros ULI.

Variables: L I V L'
IH : forall L I V L', updateListIndex L I V L' * -> is_integer I
ULI : updateListIndex L I V L' @
============================
 is_integer I

 < ULI: case ULI.

Subgoal 1:

Variables: V Tl VOld
IH : forall L I V L', updateListIndex L I V L' * -> is_integer I
============================
 is_integer 0

 < search.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
============================
 is_integer I

 < IsI1: apply IH to ULI1.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
IsI1 : is_integer I1
============================
 is_integer I

 < apply minus_integer_is_integer_result to _ ULI.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
IsI1 : is_integer I1
H1 : is_integer I
H2 : is_integer 1
============================
 is_integer I

 < search.

Proof completed.

 < Theorem updateListIndex_pos :
     forall L I V L', updateListIndex L I V L' -> I >= 0.

============================
 forall L I V L', updateListIndex L I V L' -> I >= 0

 < induction on 1.

IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
============================
 forall L I V L', updateListIndex L I V L' @ -> I >= 0

 < intros ULI.

Variables: L I V L'
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
ULI : updateListIndex L I V L' @
============================
 I >= 0

 < IsI: apply updateListIndex_is_integer to ULI.

Variables: L I V L'
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
ULI : updateListIndex L I V L' @
IsI : is_integer I
============================
 I >= 0

 < ULI: case ULI.

Subgoal 1:

Variables: V Tl VOld
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer 0
============================
 0 >= 0

 < search.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
============================
 I >= 0

 < GEq: apply IH to ULI1.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEq : I1 >= 0
============================
 I >= 0

 < P: apply minus_plus_same_integer to _ _ ULI.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEq : I1 >= 0
P : I1 + 1 = I
============================
 I >= 0

 < IsI1: apply updateListIndex_is_integer to ULI1.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEq : I1 >= 0
P : I1 + 1 = I
IsI1 : is_integer I1
============================
 I >= 0

 < P': apply plus_integer_comm to _ _ P.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEq : I1 >= 0
P : I1 + 1 = I
IsI1 : is_integer I1
P' : 1 + I1 = I
============================
 I >= 0

 < L: apply lt_plus_one to P' _.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEq : I1 >= 0
P : I1 + 1 = I
IsI1 : is_integer I1
P' : 1 + I1 = I
L : I1 < I
============================
 I >= 0

 < LEq: case GEq.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
P : I1 + 1 = I
IsI1 : is_integer I1
P' : 1 + I1 = I
L : I1 < I
LEq : 0 <= I1
============================
 I >= 0

 < L': apply lesseq_less_integer_transitive to LEq L.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
P : I1 + 1 = I
IsI1 : is_integer I1
P' : 1 + I1 = I
L : I1 < I
LEq : 0 <= I1
L' : 0 < I
============================
 I >= 0

 < G: assert I > 0.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
P : I1 + 1 = I
IsI1 : is_integer I1
P' : 1 + I1 = I
L : I1 < I
LEq : 0 <= I1
L' : 0 < I
G : I > 0
============================
 I >= 0

 < apply greater_integer_greatereq to G.

Subgoal 2:

Variables: I V I1 TlNew X Tl
IH : forall L I V L', updateListIndex L I V L' * -> I >= 0
IsI : is_integer I
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
P : I1 + 1 = I
IsI1 : is_integer I1
P' : 1 + I1 = I
L : I1 < I
LEq : 0 <= I1
L' : 0 < I
G : I > 0
H1 : I >= 0
============================
 I >= 0

 < search.

Proof completed.

 < Define listy : value -> prop by
   listy nilVal;
   listy (consVal Hd Tl) :=
     listy Tl.

 < Define flipOnto : value -> value -> value -> prop by
   flipOnto nilVal L L;
   flipOnto (consVal H T) L L' :=
     flipOnto T (consVal H L) L'.

 < Theorem eval_update_loop2 :
     forall (Hold : string) (SaveI : string) (SaveE : string) (L : string) V H HoldL LVal G FE VI,
       listy HoldL -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV.

============================
 forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
   listy HoldL -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
   is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
   matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
   false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L -> false) ->
   lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
   exists G' LV,
     (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
     replaceScopes L LV G G') /\
     flipOnto (consVal H HoldL) LVal LV

 < induction on 1.

IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
============================
 forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
   listy HoldL @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
   is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
   matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
   false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L -> false) ->
   lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
   exists G' LV,
     (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
     replaceScopes L LV G G') /\
     flipOnto (consVal H HoldL) LVal LV

 < intros ListyH IsFE IsCtx M0 NEqHI NEqHL NEqIE NEqIL NEqHE NEqEL LS.

Variables: Hold SaveI SaveE L V H HoldL LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
ListyH : listy HoldL @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H HoldL) LVal LV

 < ListyH: case ListyH.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H nilVal) LVal LV

 < EvCondA: assert <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal [].

Subgoal 1.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []

 < search 20.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H nilVal) LVal LV

 < EvBody1A: assert exists G',
     <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
     replaceScopes L (consVal H LVal) G G'.

Subgoal 1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < Is+: assert is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)).

Subgoal 1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < IsL: apply lookupScopes_is to _ LS.

Subgoal 1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < LS: assert lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal.

Subgoal 1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < apply lookupScopes_is_key to _ LS.

Subgoal 1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < RS: apply lookupScopes_replaceScopes_exists to _ _ LS with
         V' = consVal H LVal.

Subgoal 1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI R
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) R
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < RS: case RS (keep).

Subgoal 1.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS1 : mem (L, I) [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] L LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < M: case RS1.

Subgoal 1.2.1.1:

Variables: Hold SaveI SaveE V H LVal G FE VI LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = Hold -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = Hold -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = Hold -> false
LS : lookupScopes Hold ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes Hold ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string Hold
RS : replaceScopes Hold (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((Hold, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] Hold LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign Hold (cons (head (name Hold)) (name Hold))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes Hold (consVal H LVal) G G'

 < apply NEqHL to _.

Subgoal 1.2.1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I) [(SaveI, VI), (SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < M: case M.

Subgoal 1.2.1.2.1:

Variables: Hold SaveI SaveE V H LVal G FE VI LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveI -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveI -> false
LS : lookupScopes SaveI ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes SaveI ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string SaveI
RS : replaceScopes SaveI (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((SaveI, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] SaveI LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (cons (head (name Hold)) (name SaveI))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes SaveI (consVal H LVal) G G'

 < apply NEqIL to _.

Subgoal 1.2.1.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I) [(SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < M: case M.

Subgoal 1.2.1.2.2.1:

Variables: Hold SaveI SaveE V H LVal G FE VI LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveE -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveE -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveE -> false
LS : lookupScopes SaveE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes SaveE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string SaveE
RS : replaceScopes SaveE (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((SaveE, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] SaveE LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign SaveE (cons (head (name Hold)) (name SaveE))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes SaveE (consVal H LVal) G G'

 < apply NEqEL to _.

Subgoal 1.2.1.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I) []
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < case M.

Subgoal 1.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI New
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
Is+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G))
IsL : is_value LVal
LS1 : lookupScopes L ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L (consVal H LVal) G New
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < search 20.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : exists G',
             <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) [] /\
             replaceScopes L (consVal H LVal) G G'
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H nilVal) LVal LV

 < EvBody1A: case EvBody1A.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H nilVal) LVal LV

 < EvBody1B: assert <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) [].

Subgoal 1.3:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) []

 < unfold .

Subgoal 1.3:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 exists V1,
   <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (tail (name Hold)) V1 [] /\
   replaceScopes Hold V1 ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'))

 < exists nilVal.

Subgoal 1.3:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (tail (name Hold)) nilVal [] /\
 replaceScopes Hold nilVal ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'))

 < split.

Subgoal 1.3.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (tail (name Hold)) nilVal []

 < search 20.

Subgoal 1.3.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 replaceScopes Hold nilVal ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'))

 < unfold .

Subgoal 1.3.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 no_lookup [] Hold

 < search.

Subgoal 1.3.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 replaceScopes Hold nilVal ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G') ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')

 < unfold .

Subgoal 1.3.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 exists I,
   mem (Hold, I) [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] /\
   remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < exists consVal H nilVal.

Subgoal 1.3.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 mem (Hold, consVal H nilVal) [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] /\
 remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < split.

Subgoal 1.3.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 mem (Hold, consVal H nilVal) [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]

 < search.

Subgoal 1.3.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < unfold .

Subgoal 1.3.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [(SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < unfold .

Subgoal 1.3.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 SaveI = Hold -> false

 < intros E.

Subgoal 1.3.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
E : SaveI = Hold
============================
 false

 < case E.

Subgoal 1.3.2.2.2.1:

Variables: Hold SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (Hold, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = Hold -> false
NEqHL : Hold = L -> false
NEqIE : Hold = SaveE -> false
NEqIL : Hold = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (Hold, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (Hold, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (Hold, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (Hold, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 false

 < backchain NEqHI.

Subgoal 1.3.2.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [(SaveE, V)] Hold [(SaveE, V)]

 < unfold .

Subgoal 1.3.2.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 SaveE = Hold -> false

 < intros E.

Subgoal 1.3.2.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
E : SaveE = Hold
============================
 false

 < case E.

Subgoal 1.3.2.2.2.2.1:

Variables: Hold SaveI L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (Hold, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = Hold -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = Hold -> false
NEqEL : Hold = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (Hold, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (Hold, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (Hold, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (Hold, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 false

 < backchain NEqHE.

Subgoal 1.3.2.2.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [] Hold []

 < search.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H nilVal) LVal LV

 < EvCondB: assert <evalExpr {P}> FE ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) (not (null (name Hold))) falseVal [].

Subgoal 1.4:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) []
============================
 <evalExpr {P}> FE ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) (not (null (name Hold))) falseVal []

 < search 20.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvCondB : <evalExpr {P}> FE ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) (not (null (name Hold))) falseVal []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H nilVal) LVal LV

 < exists G',
   consVal H LVal.

Subgoal 1:

Variables: Hold SaveI SaveE L V H LVal G FE VI G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) LVal
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) []
EvCondB : <evalExpr {P}> FE ([]::([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G')) (not (null (name Hold))) falseVal []
============================
 (<evalStmt {P}> FE ([(Hold, consVal H nilVal), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
 replaceScopes L (consVal H LVal) G G') /\
 flipOnto (consVal H nilVal) LVal (consVal H LVal)

 < search 20.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvCondA: assert <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal [].

Subgoal 2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []

 < search 20.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvBody1A: assert exists G',
     <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
     replaceScopes L (consVal H LVal) G G'.

Subgoal 2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < IsL: apply lookupScopes_is to _ LS.

Subgoal 2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < apply lookupScopes_is_key to _ LS.

Subgoal 2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < RS: apply lookupScopes_replaceScopes_exists to _ _ LS with
         V' = consVal H LVal.

Subgoal 2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd R
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) R
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < RS: case RS (keep).

Subgoal 2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS1 : mem (L, I) [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] L LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < M: case RS1.

Subgoal 2.2.1.1:

Variables: Hold SaveI SaveE V H LVal G FE VI Tl Hd LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = Hold -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = Hold -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = Hold -> false
LS : lookupScopes Hold ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string Hold
RS : replaceScopes Hold (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((Hold, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] Hold LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign Hold (cons (head (name Hold)) (name Hold))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes Hold (consVal H LVal) G G'

 < apply NEqHL to _.

Subgoal 2.2.1.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I) [(SaveI, VI), (SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < M: case M.

Subgoal 2.2.1.2.1:

Variables: Hold SaveI SaveE V H LVal G FE VI Tl Hd LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveI -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveI -> false
LS : lookupScopes SaveI ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string SaveI
RS : replaceScopes SaveI (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((SaveI, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] SaveI LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (cons (head (name Hold)) (name SaveI))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes SaveI (consVal H LVal) G G'

 < apply NEqIL to _.

Subgoal 2.2.1.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I) [(SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < M: case M.

Subgoal 2.2.1.2.2.1:

Variables: Hold SaveI SaveE V H LVal G FE VI Tl Hd LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveE -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveE -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveE -> false
LS : lookupScopes SaveE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string SaveE
RS : replaceScopes SaveE (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((SaveE, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] SaveE LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign SaveE (cons (head (name Hold)) (name SaveE))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes SaveE (consVal H LVal) G G'

 < apply NEqEL to _.

Subgoal 2.2.1.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd I LRemain
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (((L, consVal H LVal)::LRemain)::G)
RS2 : remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I) []
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < case M.

Subgoal 2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd New
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
IsL : is_value LVal
H1 : is_string L
RS : replaceScopes L (consVal H LVal) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L (consVal H LVal) G New
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
   replaceScopes L (consVal H LVal) G G'

 < search 20.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : exists G',
             <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) [] /\
             replaceScopes L (consVal H LVal) G G'
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvBody1A: case EvBody1A.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvBody1B: assert <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) [].

Subgoal 2.3:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []

 < unfold .

Subgoal 2.3:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 exists V1,
   <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (tail (name Hold)) V1 [] /\
   replaceScopes Hold V1 ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G'))

 < exists consVal Hd Tl.

Subgoal 2.3:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (tail (name Hold)) (consVal Hd Tl) [] /\
 replaceScopes Hold (consVal Hd Tl) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G'))

 < split.

Subgoal 2.3.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (tail (name Hold)) (consVal Hd Tl) []

 < search 20.

Subgoal 2.3.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 replaceScopes Hold (consVal Hd Tl) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G'))

 < unfold .

Subgoal 2.3.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 no_lookup [] Hold

 < search.

Subgoal 2.3.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 replaceScopes Hold (consVal Hd Tl) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G') ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')

 < unfold .

Subgoal 2.3.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 exists I,
   mem (Hold, I) [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] /\
   remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < exists consVal H (consVal Hd Tl).

Subgoal 2.3.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 mem (Hold, consVal H (consVal Hd Tl)) [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] /\
 remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < split.

Subgoal 2.3.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 mem (Hold, consVal H (consVal Hd Tl)) [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]

 < search.

Subgoal 2.3.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < unfold .

Subgoal 2.3.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [(SaveI, VI), (SaveE, V)] Hold [(SaveI, VI), (SaveE, V)]

 < unfold .

Subgoal 2.3.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 SaveI = Hold -> false

 < intros E.

Subgoal 2.3.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
E : SaveI = Hold
============================
 false

 < case E.

Subgoal 2.3.2.2.2.1:

Variables: Hold SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (Hold, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = Hold -> false
NEqHL : Hold = L -> false
NEqIE : Hold = SaveE -> false
NEqIL : Hold = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (Hold, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (Hold, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (Hold, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (Hold, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 false

 < backchain NEqHI.

Subgoal 2.3.2.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [(SaveE, V)] Hold [(SaveE, V)]

 < unfold .

Subgoal 2.3.2.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 SaveE = Hold -> false

 < intros E.

Subgoal 2.3.2.2.2.2.1:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
E : SaveE = Hold
============================
 false

 < case E.

Subgoal 2.3.2.2.2.2.1:

Variables: Hold SaveI L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (Hold, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = Hold -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = Hold -> false
NEqEL : Hold = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (Hold, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (Hold, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (Hold, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (Hold, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 false

 < backchain NEqHE.

Subgoal 2.3.2.2.2.2.2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
============================
 remove_all [] Hold []

 < search.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < LS': assert lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal).

Subgoal 2.4:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
============================
 lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)

 < apply replaceScopes_lookupScopes_same to EvBody1A1.

Subgoal 2.4:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H1 : lookupScopes L G' (consVal H LVal)
============================
 lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)

 < search.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < apply lookupScopes_is to _ LS.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case IsCtx (keep).

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is : is_list (is_pair is_string is_value) [(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]
Is1 : is_list (is_list (is_pair is_string is_value)) G
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal H (consVal Hd Tl))
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
Is : is_string Hold
Is3 : is_value (consVal H (consVal Hd Tl))
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is3.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
Is : is_string Hold
Is3 : is_value H
Is4 : is_value (consVal Hd Tl)
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is4.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is2.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_pair is_string is_value (SaveI, VI)
Is6 : is_list (is_pair is_string is_value) [(SaveE, V)]
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is2.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is6 : is_list (is_pair is_string is_value) [(SaveE, V)]
Is2 : is_string SaveI
Is7 : is_value VI
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is6.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is6 : is_pair is_string is_value (SaveE, V)
Is8 : is_list (is_pair is_string is_value) []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < Is: case Is6.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < apply lookupScopes_is_key to _ LS.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvBody1A': apply drop_proj_rel_evalStmt to EvBody1A.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < apply evalStmt_isCtx to _ _ _ EvBody1A'.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvBody1B': apply drop_proj_rel_evalStmt to EvBody1B.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < IsG'+: apply evalStmt_isCtx to _ _ _ EvBody1B'.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G'))
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < case IsG'+.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G'
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < EvB: apply IH to ListyH _ _ _ _ _ _ _ _ _ _ with
          Hold = Hold
          SaveI = SaveI
          SaveE = SaveE L = L V = V H = Hd LVal = consVal H LVal G = G' FE = FE.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G' G'1 LV
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
EvB : <evalStmt {P}> FE ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvB1 : replaceScopes L LV G' G'1
EvB2 : flipOnto (consVal Hd Tl) (consVal H LVal) LV
============================
 exists G' LV,
   (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L LV G G') /\
   flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < exists G'1,
   LV.

Subgoal 2:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G' G'1 LV
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
EvB : <evalStmt {P}> FE ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvB1 : replaceScopes L LV G' G'1
EvB2 : flipOnto (consVal Hd Tl) (consVal H LVal) LV
============================
 (<evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) [] /\
 replaceScopes L LV G G'1) /\
 flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < split.

Subgoal 2.5:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G' G'1 LV
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
EvB : <evalStmt {P}> FE ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvB1 : replaceScopes L LV G' G'1
EvB2 : flipOnto (consVal Hd Tl) (consVal H LVal) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []

 < search 20.

Subgoal 2.6:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G' G'1 LV
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
EvB : <evalStmt {P}> FE ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvB1 : replaceScopes L LV G' G'1
EvB2 : flipOnto (consVal Hd Tl) (consVal H LVal) LV
============================
 replaceScopes L LV G G'1

 < apply replaceScopes_twice to EvBody1A1 EvB1.

Subgoal 2.6:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G' G'1 LV
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
EvB : <evalStmt {P}> FE ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvB1 : replaceScopes L LV G' G'1
EvB2 : flipOnto (consVal Hd Tl) (consVal H LVal) LV
H6 : replaceScopes L LV G G'1
============================
 replaceScopes L LV G G'1

 < search.

Subgoal 2.7:

Variables: Hold SaveI SaveE L V H LVal G FE VI Tl Hd G' G'1 LV
IH : forall Hold SaveI SaveE L V H HoldL LVal G FE VI,
       listy HoldL * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       matchInt VI 0 -> (Hold = SaveI -> false) -> (Hold = L -> false) -> (SaveI = SaveE ->
       false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) -> (SaveE = L ->
       false) -> lookupScopes L ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) LVal ->
       exists G' LV,
         (<evalStmt {P}> FE ([(Hold, consVal H HoldL), (SaveI, VI), (SaveE, V)]::G) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
         replaceScopes L LV G G') /\
         flipOnto (consVal H HoldL) LVal LV
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsCtx : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)
M0 : matchInt VI 0
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
LS : lookupScopes L ([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G) LVal
ListyH : listy Tl *
EvCondA : <evalExpr {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (not (null (name Hold))) trueVal []
EvBody1A : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
EvBody1A1 : replaceScopes L (consVal H LVal) G G'
EvBody1B : <evalStmt {P}> FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
LS' : lookupScopes L ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (consVal H LVal)
H1 : is_value LVal
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value H
Is4 : is_value Hd
Is5 : is_value Tl
Is2 : is_string SaveI
Is7 : is_value VI
Is8 : is_list (is_pair is_string is_value) []
Is6 : is_string SaveE
Is9 : is_value V
H2 : is_string L
EvBody1A' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G)) (assign L (cons (head (name Hold)) (name L))) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) []
H3 : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G'))
EvBody1B' : evalStmt FE ([]::([(Hold, consVal H (consVal Hd Tl)), (SaveI, VI), (SaveE, V)]::G')) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')) []
H4 : is_list (is_pair is_string is_value) []
H5 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G')
EvB : <evalStmt {P}> FE ([(Hold, consVal Hd Tl), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvB1 : replaceScopes L LV G' G'1
EvB2 : flipOnto (consVal Hd Tl) (consVal H LVal) LV
============================
 flipOnto (consVal H (consVal Hd Tl)) LVal LV

 < search.

Proof completed.

 < Theorem proj_listUpdate_eval :
     forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL -> (Hold = SaveI -> false) -> (Hold = L -> false) ->
       (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) ->
       (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV.

============================
 forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
   updateListIndex OldL I V NewL -> (Hold = SaveI -> false) -> (Hold = L -> false) ->
   (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) ->
   (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
   is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
   lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
     ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
     matchInt VI' 0) /\
     replaceScopes L LV G G') /\
     flipOnto HoldL NewL LV

 < induction on 1.

IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
============================
 forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
   updateListIndex OldL I V NewL @ -> (Hold = SaveI -> false) -> (Hold = L -> false) ->
   (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE -> false) ->
   (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
   is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
   lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
     ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
     matchInt VI' 0) /\
     replaceScopes L LV G G') /\
     flipOnto HoldL NewL LV

 < intros ULI NEqHI NEqHL NEqIE NEqIL NEqHE NEqEL ListyH MI GEqI0 IsFE Is+ LS.

Variables: OldL I V NewL Hold HoldL SaveI SaveE G FE L VI
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
ULI : updateListIndex OldL I V NewL @
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL NewL LV

 < ULI: case ULI.

Subgoal 1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal V Tl) LV

 < EvLoop1: assert <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) [].

Subgoal 1.1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
============================
 <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []

 < search 6.

Subgoal 1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal V Tl) LV

 < EvMid_e: assert <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) [].

Subgoal 1.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
============================
 <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []

 < search 20.

Subgoal 1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal V Tl) LV

 < EvAssign: assert exists G',
     <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
     replaceScopes L (consVal V Tl) G G'.

Subgoal 1.3:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < IsL: apply lookupScopes_is to _ LS.

Subgoal 1.3:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < apply lookupScopes_is_key to _ LS.

Subgoal 1.3:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < RS: apply lookupScopes_replaceScopes_exists to _ _ LS with
         V' = consVal V Tl.

Subgoal 1.3:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld R
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
RS : replaceScopes L (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) R
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < RS: case RS (keep).

Subgoal 1.3.1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld I1 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
RS : replaceScopes L (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, consVal V Tl)::LRemain)::G)
RS1 : mem (L, I1) [(Hold, HoldL), (SaveI, VI), (SaveE, V)]
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < M: case RS1.

Subgoal 1.3.1.1:

Variables: V Hold HoldL SaveI SaveE G FE VI Tl VOld LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = Hold -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = Hold -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = Hold -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes Hold ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name Hold)) (name Hold))) (assign Hold (tail (name Hold)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name Hold))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string Hold
RS : replaceScopes Hold (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((Hold, consVal V Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] Hold LRemain
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign Hold (cons (name SaveE) (tail (name Hold)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes Hold (consVal V Tl) G G'

 < apply NEqHL to _.

Subgoal 1.3.1.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld I1 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
RS : replaceScopes L (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, consVal V Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I1) [(SaveI, VI), (SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < M: case M.

Subgoal 1.3.1.2.1:

Variables: V Hold HoldL SaveI SaveE G FE VI Tl VOld LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveI -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveI -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes SaveI ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name SaveI)) (name Hold))) (assign SaveI (tail (name SaveI)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name SaveI))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string SaveI
RS : replaceScopes SaveI (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((SaveI, consVal V Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveI LRemain
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign SaveI (cons (name SaveE) (tail (name SaveI)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes SaveI (consVal V Tl) G G'

 < apply NEqIL to _.

Subgoal 1.3.1.2.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld I1 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
RS : replaceScopes L (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, consVal V Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I1) [(SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < M: case M.

Subgoal 1.3.1.2.2.1:

Variables: V Hold HoldL SaveI SaveE G FE VI Tl VOld LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveE -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveE -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveE -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes SaveE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name SaveE)) (name Hold))) (assign SaveE (tail (name SaveE)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name SaveE))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string SaveE
RS : replaceScopes SaveE (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((SaveE, consVal V Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveE LRemain
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign SaveE (cons (name SaveE) (tail (name SaveE)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes SaveE (consVal V Tl) G G'

 < apply NEqEL to _.

Subgoal 1.3.1.2.2.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld I1 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
RS : replaceScopes L (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, consVal V Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I1) []
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < case M.

Subgoal 1.3.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
IsL : is_value (consVal VOld Tl)
H1 : is_string L
RS : replaceScopes L (consVal V Tl) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L (consVal V Tl) G New
============================
 exists G',
   <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
   replaceScopes L (consVal V Tl) G G'

 < search.

Subgoal 1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : exists G',
             <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') [] /\
             replaceScopes L (consVal V Tl) G G'
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal V Tl) LV

 < EvAssign: case EvAssign.

Subgoal 1:

Variables: V Hold HoldL SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal V Tl) LV

 < ListyH': case ListyH (keep).

Subgoal 1.4:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto nilVal (consVal V Tl) LV

 < exists G',
   consVal V Tl,
   VI.

Subgoal 1.4:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 ((<evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
 matchInt VI 0) /\
 replaceScopes L (consVal V Tl) G G') /\
 flipOnto nilVal (consVal V Tl) (consVal V Tl)

 < split.

Subgoal 1.4.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []

 < unfold .

Subgoal 1.4.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 exists EE1 O1 O2,
   <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 O1 /\
   (<evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') O2 /\
   O1 ++ O2 = [])

 < exists [(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G,
   [],
   [].

Subgoal 1.4.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) [] /\
 (<evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
 [] ++ [] = [])

 < split.

Subgoal 1.4.1.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []

 < search.

Subgoal 1.4.1.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []

 < unfold .

Subgoal 1.4.1.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 exists EE1 O1 O2,
   <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) EE1 O1 /\
   (<evalStmt {P}> FE EE1 (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') O2 /\
   O1 ++ O2 = [])

 < exists [(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G',
   [],
   [].

Subgoal 1.4.1.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
 (<evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') [] /\
 [] ++ [] = [])

 < split.

Subgoal 1.4.1.2.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []

 < search.

Subgoal 1.4.1.2.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []

 < search 20.

Subgoal 1.4.1.2.3:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 [] ++ [] = []

 < search.

Subgoal 1.4.1.3:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 [] ++ [] = []

 < search.

Subgoal 1.4.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 matchInt VI 0

 < search.

Subgoal 1.4.3:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 replaceScopes L (consVal V Tl) G G'

 < search.

Subgoal 1.4.4:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy nilVal
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
============================
 flipOnto nilVal (consVal V Tl) (consVal V Tl)

 < search.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < LS': assert lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl).

Subgoal 1.5.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
============================
 lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)

 < apply replaceScopes_lookupScopes_same to EvAssign1.

Subgoal 1.5.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
H1 : lookupScopes L G' (consVal V Tl)
============================
 lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)

 < search.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < IsL: apply lookupScopes_is to _ LS.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < Is: case Is+.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is : is_list (is_pair is_string is_value) [(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]
Is1 : is_list (is_list (is_pair is_string is_value)) G
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < Is: case Is.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < Is: case Is2.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is3 : is_list (is_pair is_string is_value) [(SaveE, V)]
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < Is: case Is3.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is3 : is_pair is_string is_value (SaveE, V)
Is4 : is_list (is_pair is_string is_value) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < Is: case Is3.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < EvAsgn': apply drop_proj_rel_evalStmt to EvAssign.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < apply lookupScopes_is_key to _ LS.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < apply evalStmt_isCtx to _ _ _ EvAsgn'.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < EvLoop2: apply eval_update_loop2 to _ _ _ _ _ _ _ _ _ _ _ with
              Hold = Hold
              SaveI = SaveI
              SaveE = SaveE
              L = L V = V H = Hd HoldL = Tl1 LVal = consVal V Tl G = G' FE = FE.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < exists G'1,
   LV,
   VI.

Subgoal 1.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 ((<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) [] /\
 matchInt VI 0) /\
 replaceScopes L LV G G'1) /\
 flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < split.

Subgoal 1.5.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []

 < unfold .

Subgoal 1.5.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 exists EE1 O1 O2,
   <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 O1 /\
   (<evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) O2 /\
   O1 ++ O2 = [])

 < exists [(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G,
   [],
   [].

Subgoal 1.5.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) [] /\
 (<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) [] /\
 [] ++ [] = [])

 < split.

Subgoal 1.5.2.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []

 < search.

Subgoal 1.5.2.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []

 < unfold .

Subgoal 1.5.2.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 exists EE1 O1 O2,
   <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) EE1 O1 /\
   (<evalStmt {P}> FE EE1 (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) O2 /\
   O1 ++ O2 = [])

 < exists [(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G',
   [],
   [].

Subgoal 1.5.2.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') [] /\
 (<evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) [] /\
 [] ++ [] = [])

 < split.

Subgoal 1.5.2.2.1:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []

 < search.

Subgoal 1.5.2.2.2:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []

 < search.

Subgoal 1.5.2.2.3:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 [] ++ [] = []

 < search.

Subgoal 1.5.2.3:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 [] ++ [] = []

 < search.

Subgoal 1.5.3:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 matchInt VI 0

 < search.

Subgoal 1.5.4:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 replaceScopes L LV G G'1

 < apply replaceScopes_twice to EvAssign1 EvLoop3.

Subgoal 1.5.4:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
H3 : replaceScopes L LV G G'1
============================
 replaceScopes L LV G G'1

 < search.

Subgoal 1.5.5:

Variables: V Hold SaveI SaveE G FE L VI Tl VOld G' Tl1 Hd G'1 LV
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal Hd Tl1)
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (consVal VOld Tl)
EvLoop1 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) []
EvMid_e : <evalExpr {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (cons (name SaveE) (tail (name L))) (consVal V Tl) []
EvAssign : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
EvAssign1 : replaceScopes L (consVal V Tl) G G'
ListyH' : listy Tl1
LS' : lookupScopes L ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (consVal V Tl)
IsL : is_value (consVal VOld Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, consVal Hd Tl1)
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) []
Is3 : is_string SaveE
Is5 : is_value V
EvAsgn' : evalStmt FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G) (assign L (cons (name SaveE) (tail (name L)))) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') []
H1 : is_string L
H2 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G')
EvLoop2 : <evalStmt {P}> FE ([(Hold, consVal Hd Tl1), (SaveI, VI), (SaveE, V)]::G') (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::G'1) []
EvLoop3 : replaceScopes L LV G' G'1
EvLoop4 : flipOnto (consVal Hd Tl1) (consVal V Tl) LV
============================
 flipOnto (consVal Hd Tl1) (consVal V Tl) LV

 < search.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < GEqI1: apply updateListIndex_pos to ULI1.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvCond: assert <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal [].

Subgoal 2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []

 < unfold .

Subgoal 2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 exists V1 O1 V2 O2 I1 I2,
   <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (name SaveI) V1 O1 /\
   (<evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (num 0) V2 O2 /\
   (matchInt V1 I1 /\ (matchInt V2 I2 /\ (I1 > I2 /\ O1 ++ O2 = []))))

 < exists VI,
   [],
   intVal 0,
   [],
   I,
   0.

Subgoal 2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (name SaveI) VI [] /\
 (<evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (num 0) (intVal 0) [] /\
 (matchInt VI I /\ (matchInt (intVal 0) 0 /\ (I > 0 /\ [] ++ [] = []))))

 < split.

Subgoal 2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (name SaveI) VI []

 < search.

Subgoal 2.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (num 0) (intVal 0) []

 < search.

Subgoal 2.1.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 matchInt VI I

 < search.

Subgoal 2.1.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 matchInt (intVal 0) 0

 < search.

Subgoal 2.1.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 I > 0

 < Or: apply greatereq_integer_greater_or_eq to GEqI0.

Subgoal 2.1.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
Or : I > 0 \/ I = 0
============================
 I > 0

 < C: case Or.

Subgoal 2.1.5.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
C : I > 0
============================
 I > 0

 < search.

Subgoal 2.1.5.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : 0 - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 0 > 0

 < compute ULI.

Subgoal 2.1.5.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : 0 - 1 = -1
ULI1 : updateListIndex Tl -1 V TlNew *
GEqI1 : -1 >= 0
============================
 0 > 0

 < LEq: case GEqI1.

Subgoal 2.1.5.2:

Variables: V Hold HoldL SaveI SaveE G FE L VI TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI 0
GEqI0 : 0 >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : 0 - 1 = -1
ULI1 : updateListIndex Tl -1 V TlNew *
LEq : 0 <= -1
============================
 0 > 0

 < case LEq.

Subgoal 2.1.6:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
============================
 [] ++ [] = []

 < search.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvBodyA: assert <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) [].

Subgoal 2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []

 < unfold .

Subgoal 2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 exists V1,
   <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (minus (name SaveI) (num 1)) V1 [] /\
   replaceScopes SaveI V1 ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G))

 < exists intVal I1.

Subgoal 2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (minus (name SaveI) (num 1)) (intVal I1) [] /\
 replaceScopes SaveI (intVal I1) ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G))

 < split.

Subgoal 2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (minus (name SaveI) (num 1)) (intVal I1) []

 < unfold .

Subgoal 2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 exists V1 O1 V2 O2 I2 I3,
   <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (name SaveI) V1 O1 /\
   (<evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (num 1) V2 O2 /\
   (matchInt V1 I2 /\ (matchInt V2 I3 /\ (I2 - I3 = I1 /\ O1 ++ O2 = []))))

 < exists VI,
   [],
   intVal 1,
   [],
   I,
   1.

Subgoal 2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (name SaveI) VI [] /\
 (<evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (num 1) (intVal 1) [] /\
 (matchInt VI I /\ (matchInt (intVal 1) 1 /\ (I - 1 = I1 /\ [] ++ [] = []))))

 < split.

Subgoal 2.2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (name SaveI) VI []

 < search.

Subgoal 2.2.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 <evalExpr {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (num 1) (intVal 1) []

 < search.

Subgoal 2.2.1.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 matchInt VI I

 < search.

Subgoal 2.2.1.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 matchInt (intVal 1) 1

 < search.

Subgoal 2.2.1.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 I - 1 = I1

 < search.

Subgoal 2.2.1.6:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 [] ++ [] = []

 < search.

Subgoal 2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 replaceScopes SaveI (intVal I1) ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G))

 < unfold .

Subgoal 2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 no_lookup [] SaveI

 < search.

Subgoal 2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 replaceScopes SaveI (intVal I1) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)

 < unfold .

Subgoal 2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 exists I,
   mem (SaveI, I) [(Hold, HoldL), (SaveI, VI), (SaveE, V)] /\
   remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveI [(Hold, HoldL), (SaveE, V)]

 < exists VI.

Subgoal 2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 mem (SaveI, VI) [(Hold, HoldL), (SaveI, VI), (SaveE, V)] /\
 remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveI [(Hold, HoldL), (SaveE, V)]

 < split.

Subgoal 2.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 mem (SaveI, VI) [(Hold, HoldL), (SaveI, VI), (SaveE, V)]

 < search.

Subgoal 2.2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveI [(Hold, HoldL), (SaveE, V)]

 < unfold .

Subgoal 2.2.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 Hold = SaveI -> false

 < intros E.

Subgoal 2.2.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
E : Hold = SaveI
============================
 false

 < case E.

Subgoal 2.2.2.2.2.1:

Variables: I V HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : SaveI = SaveI -> false
NEqHL : SaveI = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : SaveI = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(SaveI, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(SaveI, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(SaveI, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 false

 < backchain NEqHI.

Subgoal 2.2.2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 remove_all [(SaveI, VI), (SaveE, V)] SaveI [(SaveE, V)]

 < unfold .

Subgoal 2.2.2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 remove_all [(SaveE, V)] SaveI [(SaveE, V)]

 < unfold .

Subgoal 2.2.2.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 SaveE = SaveI -> false

 < intros E.

Subgoal 2.2.2.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
E : SaveE = SaveI
============================
 false

 < case E.

Subgoal 2.2.2.2.2.2.1:

Variables: I V Hold HoldL SaveI G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveI -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveI -> false
NEqEL : SaveI = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveI, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveI, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveI, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 false

 < backchain NEqIE.

Subgoal 2.2.2.2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
============================
 remove_all [] SaveI []

 < search.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvBodyB: assert <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) [].

Subgoal 2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
============================
 <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []

 < EvL: assert <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) [].

Subgoal 2.3.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < LS: case LS.

Subgoal 2.3.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
LS : lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < L: case LS.

Subgoal 2.3.1.1.1:

Variables: I V SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : L = SaveI -> false
NEqHL : L = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : L = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal X Tl)
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (L, consVal X Tl), (SaveE, V)]::G)) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (L, consVal X Tl), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < apply NEqHL to _.

Subgoal 2.3.1.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
L : Hold = L -> false
L1 : lookup [(SaveI, VI), (SaveE, V)] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < L: case L1.

Subgoal 2.3.1.1.2.1:

Variables: I V Hold HoldL SaveE G FE L I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = L -> false
NEqHL : Hold = L -> false
NEqIE : L = SaveE -> false
NEqIL : L = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt (consVal X Tl) I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G) (greater (name L) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G)) (assign L (minus (name L) (num 1))) ([]::([(L, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
L : Hold = L -> false
============================
 <evalExpr {P}> FE ([]::([(L, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < apply NEqIL to _.

Subgoal 2.3.1.1.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
L : Hold = L -> false
L1 : SaveI = L -> false
L2 : lookup [(SaveE, V)] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < L: case L2.

Subgoal 2.3.1.1.2.2.1:

Variables: I Hold HoldL SaveI G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = L -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = L -> false
NEqEL : L = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 (consVal X Tl) TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (L, consVal X Tl)]::G)) []
L : Hold = L -> false
L1 : SaveI = L -> false
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (L, consVal X Tl)]::G)) (name L) (consVal X Tl) []

 < apply NEqEL to _.

Subgoal 2.3.1.1.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
L : Hold = L -> false
L1 : SaveI = L -> false
L2 : SaveE = L -> false
L3 : lookup [] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < case L3.

Subgoal 2.3.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
LS : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
LS1 : lookupScopes L G (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < assert no_lookup [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] L.

Subgoal 2.3.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
LS : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
LS1 : lookupScopes L G (consVal X Tl)
H1 : no_lookup [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] L
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []

 < search.

Subgoal 2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []

 < unfold .

Subgoal 2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 exists V1,
   <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (cons (head (name L)) (name Hold)) V1 [] /\
   replaceScopes Hold V1 ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G))

 < exists consVal X HoldL.

Subgoal 2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (cons (head (name L)) (name Hold)) (consVal X HoldL) [] /\
 replaceScopes Hold (consVal X HoldL) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G))

 < split.

Subgoal 2.3.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (cons (head (name L)) (name Hold)) (consVal X HoldL) []

 < unfold .

Subgoal 2.3.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 exists E_P V_P O_P O1 O2,
   (<evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (head (name L)) X O1 /\
   (<evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL O2 /\
   O1 ++ O2 = [])) /\
   (|{expr}- cons (head (name L)) (name Hold) ~~> E_P /\
   <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) E_P V_P O_P)

 < exists recBuild (consRecFieldExprs "null" matchEval:host:false (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs))),
   recVal [("null", falseVal), ("head", X), ("tail", HoldL)],
   [],
   [],
   [].

Subgoal 2.3.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 (<evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (head (name L)) X [] /\
 (<evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL [] /\
 [] ++ [] = [])) /\
 (|{expr}- cons (head (name L)) (name Hold) ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs))) /\
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", X), ("tail", HoldL)]) [])

 < split.

Subgoal 2.3.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (head (name L)) X []

 < search.

Subgoal 2.3.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL []

 < assert lookupScopes Hold ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) HoldL.

Subgoal 2.3.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 lookupScopes Hold ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) HoldL

 < unfold .

Subgoal 2.3.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 lookup [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] Hold HoldL

 < unfold .

Subgoal 2.3.2.2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 SaveI = Hold -> false

 < intros E.

Subgoal 2.3.2.2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
E : SaveI = Hold
============================
 false

 < case E.

Subgoal 2.3.2.2.1.1:

Variables: I V Hold HoldL SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = Hold -> false
NEqHL : Hold = L -> false
NEqIE : Hold = SaveE -> false
NEqIL : Hold = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G) (greater (name Hold) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G)) (assign Hold (minus (name Hold) (num 1))) ([]::([(Hold, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(Hold, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 false

 < backchain NEqHI.

Subgoal 2.3.2.2.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 lookup [(Hold, HoldL), (SaveE, V)] Hold HoldL

 < search.

Subgoal 2.3.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
H1 : lookupScopes Hold ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) HoldL
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL []

 < search.

Subgoal 2.3.2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 [] ++ [] = []

 < search.

Subgoal 2.3.2.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 |{expr}- cons (head (name L)) (name Hold) ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs)))

 < search.

Subgoal 2.3.2.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", X), ("tail", HoldL)]) []

 < unfold .

Subgoal 2.3.2.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "null" false (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs))) [("null", falseVal), ("head", X), ("tail", HoldL)] []

 < unfold .

Subgoal 2.3.2.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 exists O1 O2,
   <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) false falseVal O1 /\
   (<evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs)) [("head", X), ("tail", HoldL)] O2 /\
   O1 ++ O2 = [])

 < exists [],
   [].

Subgoal 2.3.2.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) false falseVal [] /\
 (<evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs)) [("head", X), ("tail", HoldL)] [] /\
 [] ++ [] = [])

 < split.

Subgoal 2.3.2.5.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) false falseVal []

 < search.

Subgoal 2.3.2.5.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "head" (head (name L)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs)) [("head", X), ("tail", HoldL)] []

 < unfold .

Subgoal 2.3.2.5.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 exists O1 O2,
   <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (head (name L)) X O1 /\
   (<evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs) [("tail", HoldL)] O2 /\
   O1 ++ O2 = [])

 < exists [],
   [].

Subgoal 2.3.2.5.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (head (name L)) X [] /\
 (<evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs) [("tail", HoldL)] [] /\
 [] ++ [] = [])

 < split.

Subgoal 2.3.2.5.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (head (name L)) X []

 < search.

Subgoal 2.3.2.5.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (consRecFieldExprs "tail" (name Hold) nilRecFieldExprs) [("tail", HoldL)] []

 < unfold .

Subgoal 2.3.2.5.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 exists O1 O2,
   <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL O1 /\
   (<evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) nilRecFieldExprs [] O2 /\
   O1 ++ O2 = [])

 < exists [],
   [].

Subgoal 2.3.2.5.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL [] /\
 (<evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) nilRecFieldExprs [] [] /\
 [] ++ [] = [])

 < split.

Subgoal 2.3.2.5.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL []

 < assert lookupScopes Hold ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) HoldL.

Subgoal 2.3.2.5.2.2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 lookupScopes Hold ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) HoldL

 < unfold .

Subgoal 2.3.2.5.2.2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 lookup [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] Hold HoldL

 < unfold .

Subgoal 2.3.2.5.2.2.1.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 SaveI = Hold -> false

 < intros E.

Subgoal 2.3.2.5.2.2.1.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
E : SaveI = Hold
============================
 false

 < case E.

Subgoal 2.3.2.5.2.2.1.1.1:

Variables: I V Hold HoldL SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = Hold -> false
NEqHL : Hold = L -> false
NEqIE : Hold = SaveE -> false
NEqIL : Hold = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G) (greater (name Hold) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G)) (assign Hold (minus (name Hold) (num 1))) ([]::([(Hold, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(Hold, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 false

 < backchain NEqHI.

Subgoal 2.3.2.5.2.2.1.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 lookup [(Hold, HoldL), (SaveE, V)] Hold HoldL

 < search.

Subgoal 2.3.2.5.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
H1 : lookupScopes Hold ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) HoldL
============================
 <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name Hold) HoldL []

 < search.

Subgoal 2.3.2.5.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 <evalRecFields {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) nilRecFieldExprs [] []

 < search.

Subgoal 2.3.2.5.2.2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 [] ++ [] = []

 < search.

Subgoal 2.3.2.5.2.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 [] ++ [] = []

 < search.

Subgoal 2.3.2.5.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 [] ++ [] = []

 < search.

Subgoal 2.3.3:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 replaceScopes Hold (consVal X HoldL) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G))

 < unfold .

Subgoal 2.3.3.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 no_lookup [] Hold

 < search.

Subgoal 2.3.3.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 replaceScopes Hold (consVal X HoldL) ([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)

 < unfold .

Subgoal 2.3.3.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 exists I,
   mem (Hold, I) [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] /\
   remove_all [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] Hold [(SaveI, intVal I1), (SaveE, V)]

 < exists HoldL.

Subgoal 2.3.3.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 mem (Hold, HoldL) [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] /\
 remove_all [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] Hold [(SaveI, intVal I1), (SaveE, V)]

 < split.

Subgoal 2.3.3.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 mem (Hold, HoldL) [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]

 < search.

Subgoal 2.3.3.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 remove_all [(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)] Hold [(SaveI, intVal I1), (SaveE, V)]

 < unfold .

Subgoal 2.3.3.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 SaveI = Hold -> false

 < intros E.

Subgoal 2.3.3.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
E : SaveI = Hold
============================
 false

 < case E.

Subgoal 2.3.3.2.2.1:

Variables: I V Hold HoldL SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = Hold -> false
NEqHL : Hold = L -> false
NEqIE : Hold = SaveE -> false
NEqIL : Hold = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G) (greater (name Hold) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (Hold, VI), (SaveE, V)]::G)) (assign Hold (minus (name Hold) (num 1))) ([]::([(Hold, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(Hold, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 false

 < backchain NEqHI.

Subgoal 2.3.3.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 remove_all [(Hold, HoldL), (SaveE, V)] Hold [(SaveE, V)]

 < unfold .

Subgoal 2.3.3.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 remove_all [(SaveE, V)] Hold [(SaveE, V)]

 < unfold .

Subgoal 2.3.3.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 SaveE = Hold -> false

 < intros E.

Subgoal 2.3.3.2.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
E : SaveE = Hold
============================
 false

 < case E.

Subgoal 2.3.3.2.2.2.1:

Variables: I V Hold HoldL SaveI G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = Hold -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = Hold -> false
NEqEL : Hold = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (Hold, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (Hold, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (Hold, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (Hold, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (Hold, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (Hold, V)]::G)) (name L) (consVal X Tl) []
============================
 false

 < backchain NEqHE.

Subgoal 2.3.3.2.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvL : <evalExpr {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (name L) (consVal X Tl) []
============================
 remove_all [] Hold []

 < search.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvBodyC: assert exists G',
     <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
     replaceScopes L Tl G G'.

Subgoal 2.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < IsL: apply lookupScopes_is to _ LS.

Subgoal 2.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < apply lookupScopes_is_key to _ LS.

Subgoal 2.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < RS: apply lookupScopes_replaceScopes_exists to _ _ LS with
         V' = Tl.

Subgoal 2.4:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl R
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) R
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < RS: case RS (keep).

Subgoal 2.4.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl I2 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, Tl)::LRemain)::G)
RS1 : mem (L, I2) [(Hold, HoldL), (SaveI, VI), (SaveE, V)]
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < M: case RS1.

Subgoal 2.4.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE VI I1 TlNew X Tl LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = Hold -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = Hold -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = Hold -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes Hold ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name Hold)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string Hold
RS : replaceScopes Hold Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((Hold, Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] Hold LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign Hold (tail (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes Hold Tl G G'

 < apply NEqHL to _.

Subgoal 2.4.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl I2 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I2) [(SaveI, VI), (SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < M: case M.

Subgoal 2.4.1.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE VI I1 TlNew X Tl LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveI -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveI -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes SaveI ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name SaveI)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string SaveI
RS : replaceScopes SaveI Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((SaveI, Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveI LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign SaveI (tail (name SaveI))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes SaveI Tl G G'

 < apply NEqIL to _.

Subgoal 2.4.1.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl I2 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I2) [(SaveE, V)]
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < M: case M.

Subgoal 2.4.1.2.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE VI I1 TlNew X Tl LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = SaveE -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = SaveE -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = SaveE -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes SaveE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name SaveE)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string SaveE
RS : replaceScopes SaveE Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((SaveE, Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] SaveE LRemain
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign SaveE (tail (name SaveE))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes SaveE Tl G G'

 < apply NEqEL to _.

Subgoal 2.4.1.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl I2 LRemain
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (((L, Tl)::LRemain)::G)
RS2 : remove_all [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L LRemain
M : mem (L, I2) []
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < case M.

Subgoal 2.4.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 exists G',
   <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
   replaceScopes L Tl G G'

 < exists New.

Subgoal 2.4.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::New)) [] /\
 replaceScopes L Tl G New

 < split.

Subgoal 2.4.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::New)) []

 < unfold .

Subgoal 2.4.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 exists V1,
   <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) V1 [] /\
   replaceScopes L V1 ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::New))

 < exists Tl.

Subgoal 2.4.2.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl [] /\
 replaceScopes L Tl ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::New))

 < split.

Subgoal 2.4.2.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < LS: case LS.

Subgoal 2.4.2.1.1.1:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
LS : lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < L: case LS.

Subgoal 2.4.2.1.1.1.1:

Variables: I V SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : L = SaveI -> false
NEqHL : L = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : L = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy (consVal X Tl)
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (L, consVal X Tl), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (L, consVal X Tl), (SaveE, V)]::G)) (assign L (cons (head (name L)) (name L))) ([]::([(L, consVal X (consVal X Tl)), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::G) ([(L, consVal X Tl), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(L, consVal X Tl), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 <evalExpr {P}> FE ([]::([(L, consVal X (consVal X Tl)), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < apply NEqHL to _.

Subgoal 2.4.2.1.1.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
L : Hold = L -> false
L1 : lookup [(SaveI, VI), (SaveE, V)] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < L: case L1.

Subgoal 2.4.2.1.1.1.2.1:

Variables: I V Hold HoldL SaveE G FE L I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = L -> false
NEqHL : Hold = L -> false
NEqIE : L = SaveE -> false
NEqIL : L = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt (consVal X Tl) I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G) (greater (name L) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G)) (assign L (minus (name L) (num 1))) ([]::([(L, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(L, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (L, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::G) ([(Hold, HoldL), (L, consVal X Tl), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (L, consVal X Tl), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
L : Hold = L -> false
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (L, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < apply NEqIL to _.

Subgoal 2.4.2.1.1.1.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
L : Hold = L -> false
L1 : SaveI = L -> false
L2 : lookup [(SaveE, V)] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < L: case L2.

Subgoal 2.4.2.1.1.1.2.2.1:

Variables: I Hold HoldL SaveI G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = L -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = L -> false
NEqEL : L = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 (consVal X Tl) TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (L, consVal X Tl)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (L, consVal X Tl)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (L, consVal X Tl)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::G) ([(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (L, consVal X Tl)] L
RS2 : replaceScopes L Tl G New
L : Hold = L -> false
L1 : SaveI = L -> false
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (L, consVal X Tl)]::G)) (tail (name L)) Tl []

 < apply NEqEL to _.

Subgoal 2.4.2.1.1.1.2.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
L : Hold = L -> false
L1 : SaveI = L -> false
L2 : SaveE = L -> false
L3 : lookup [] L (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < case L3.

Subgoal 2.4.2.1.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
LS : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
LS1 : lookupScopes L G (consVal X Tl)
============================
 <evalExpr {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (tail (name L)) Tl []

 < search 20.

Subgoal 2.4.2.1.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 replaceScopes L Tl ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::New))

 < search 6.

Subgoal 2.4.2.2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl New
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
IsL : is_value (consVal X Tl)
H1 : is_string L
RS : replaceScopes L Tl ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::New)
RS1 : no_lookup [(Hold, HoldL), (SaveI, VI), (SaveE, V)] L
RS2 : replaceScopes L Tl G New
============================
 replaceScopes L Tl G New

 < search.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
EvBodyC : exists G',
            <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [] /\
            replaceScopes L Tl G G'
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvBodyC: case EvBodyC.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
EvBodyC : <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
EvBodyC1 : replaceScopes L Tl G G'
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvBody: assert <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) [].

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyA : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (assign SaveI (minus (name SaveI) (num 1))) ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) []
EvBodyB : <evalStmt {P}> FE ([]::([(SaveI, intVal I1), (Hold, HoldL), (SaveE, V)]::G)) (assign Hold (cons (head (name L)) (name Hold))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) []
EvBodyC : <evalStmt {P}> FE ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G)) (assign L (tail (name L))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < clear EvBodyA
   EvBodyB
   EvBodyC.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < ListyH': assert listy (consVal X HoldL).

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < IsL: apply lookupScopes_is to _ LS.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Is+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is+.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is : is_list (is_pair is_string is_value) [(Hold, HoldL), (SaveI, VI), (SaveE, V)]
Is1 : is_list (is_list (is_pair is_string is_value)) G
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_pair is_string is_value (Hold, HoldL)
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is2 : is_list (is_pair is_string is_value) [(SaveI, VI), (SaveE, V)]
Is : is_string Hold
Is3 : is_value HoldL
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is2.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_pair is_string is_value (SaveI, VI)
Is4 : is_list (is_pair is_string is_value) [(SaveE, V)]
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is2.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is4 : is_list (is_pair is_string is_value) [(SaveE, V)]
Is2 : is_string SaveI
Is5 : is_value VI
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is4.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is4 : is_pair is_string is_value (SaveE, V)
Is6 : is_list (is_pair is_string is_value) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Is: case Is4.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
IsL : is_value (consVal X Tl)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < case IsL.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < apply matchInt_is to _ MI.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < apply minus_integer_is_integer to _ _ ULI.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvBody': apply drop_proj_rel_evalStmt to EvBody.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < apply lookupScopes_is_key to _ LS.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < IsG'+: apply evalStmt_isCtx to _ _ _ EvBody'.

Subgoal 2.5:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
============================
 is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G))

 < search 6.

Subgoal 2.6:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
============================
 is_stmt (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))

 < search 8.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G'))
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < case IsG'+.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < IsG'+: assert is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G').

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < assert lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl.

Subgoal 2.7:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
============================
 lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl

 < apply replaceScopes_lookupScopes_same to EvBodyC1.

Subgoal 2.7:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L G' Tl
============================
 lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl

 < search.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < Sub: apply IH to ULI1 NEqHI NEqHL NEqIE NEqIL NEqHE NEqEL ListyH' _ _ _ IsG'+ _.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI'
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvSub: case Sub.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1 O1 O2
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 O1
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) O2
EvSub2 : O1 ++ O2 = []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < case EvSub2.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < EvLoop1: assert <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 [].

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
============================
 exists G' LV VI',
   ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
   matchInt VI' 0) /\
   replaceScopes L LV G G') /\
   flipOnto HoldL (consVal X TlNew) LV

 < exists G'1,
   LV,
   VI'.

Subgoal 2:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
============================
 ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) [] /\
 matchInt VI' 0) /\
 replaceScopes L LV G G'1) /\
 flipOnto HoldL (consVal X TlNew) LV

 < split.

Subgoal 2.8:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
============================
 <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []

 < search.

Subgoal 2.9:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
============================
 matchInt VI' 0

 < search.

Subgoal 2.10:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
============================
 replaceScopes L LV G G'1

 < apply replaceScopes_twice to EvBodyC1 Sub2.

Subgoal 2.10:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
H9 : replaceScopes L LV G G'1
============================
 replaceScopes L LV G G'1

 < search.

Subgoal 2.11:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
Sub3 : flipOnto (consVal X HoldL) TlNew LV
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
============================
 flipOnto HoldL (consVal X TlNew) LV

 < case Sub3.

Subgoal 2.11:

Variables: I V Hold HoldL SaveI SaveE G FE L VI I1 TlNew X Tl G' G'1 LV VI' EE1
IH : forall OldL I V NewL Hold HoldL SaveI SaveE G FE L VI,
       updateListIndex OldL I V NewL * -> (Hold = SaveI -> false) -> (Hold = L ->
       false) -> (SaveI = SaveE -> false) -> (SaveI = L -> false) -> (Hold = SaveE ->
       false) -> (SaveE = L -> false) -> listy HoldL -> matchInt VI I -> I >= 0 ->
       is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) ->
       lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) OldL -> exists G' LV VI',
         ((<evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') [] /\
         matchInt VI' 0) /\
         replaceScopes L LV G G') /\
         flipOnto HoldL NewL LV
NEqHI : Hold = SaveI -> false
NEqHL : Hold = L -> false
NEqIE : SaveI = SaveE -> false
NEqIL : SaveI = L -> false
NEqHE : Hold = SaveE -> false
NEqEL : SaveE = L -> false
ListyH : listy HoldL
MI : matchInt VI I
GEqI0 : I >= 0
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
LS : lookupScopes L ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (consVal X Tl)
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
GEqI1 : I1 >= 0
EvCond : <evalExpr {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (greater (name SaveI) (num 0)) trueVal []
EvBodyC1 : replaceScopes L Tl G G'
EvBody : <evalStmt {P}> FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
ListyH' : listy (consVal X HoldL)
Is1 : is_list (is_list (is_pair is_string is_value)) G
Is : is_string Hold
Is3 : is_value HoldL
Is2 : is_string SaveI
Is5 : is_value VI
Is6 : is_list (is_pair is_string is_value) []
Is4 : is_string SaveE
Is7 : is_value V
H1 : is_value X
H2 : is_value Tl
H3 : is_integer I
H4 : is_integer I1
EvBody' : evalStmt FE ([]::([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L))))) ([]::([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')) []
H5 : is_string L
H6 : is_list (is_pair is_string is_value) []
H7 : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
IsG'+ : is_list (is_list (is_pair is_string is_value)) ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G')
H8 : lookupScopes L ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') Tl
Sub1 : matchInt VI' 0
Sub2 : replaceScopes L LV G' G'1
EvSub : <evalStmt {P}> FE ([(Hold, consVal X HoldL), (SaveI, intVal I1), (SaveE, V)]::G') (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
EvSub1 : <evalStmt {P}> FE EE1 (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G'1) []
EvLoop1 : <evalStmt {P}> FE ([(Hold, HoldL), (SaveI, VI), (SaveE, V)]::G) (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) EE1 []
H9 : flipOnto HoldL (consVal X TlNew) LV
============================
 flipOnto HoldL (consVal X TlNew) LV

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalStmt_forward.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < Is: case IsS.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < Ev: case Ev.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < assert SaveE = L -> false.

Subgoal 1.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
============================
 SaveE = L -> false

 < intros E.

Subgoal 1.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
E : SaveE = L
============================
 false

 < case E.

Subgoal 1.1:

Variables: Names FE EE EE' O Hold L SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy L E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name L) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) L
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
============================
 false

 < apply fresh_name_not_mem to Pr3 _.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < assert SaveI = L -> false.

Subgoal 1.2:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
============================
 SaveI = L -> false

 < intros E.

Subgoal 1.2:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
E : SaveI = L
============================
 false

 < case E.

Subgoal 1.2:

Variables: Names FE EE EE' O Hold L SaveE E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy L I) (seq (declare intTy SaveE E) (seq (assign L (name L)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name L) (num 0)) (seq (assign L (minus (name L) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) L
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
============================
 false

 < apply fresh_name_not_mem to Pr1 _.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < assert Hold = L -> false.

Subgoal 1.3:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
============================
 Hold = L -> false

 < intros E.

Subgoal 1.3:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
E : Hold = L
============================
 false

 < case E.

Subgoal 1.3:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy L (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign L (cons (head (name L)) (name L))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name L))) (seq (assign L (cons (head (name L)) (name L))) (assign L (tail (name L)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) L
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
============================
 false

 < apply fresh_name_not_mem to Pr2 _.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < assert Hold = SaveE -> false.

Subgoal 1.4:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
============================
 Hold = SaveE -> false

 < intros E.

Subgoal 1.4:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
E : Hold = SaveE
============================
 false

 < case E.

Subgoal 1.4:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveE (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveE (cons (head (name L)) (name SaveE))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveE))) (seq (assign L (cons (head (name SaveE)) (name L))) (assign SaveE (tail (name SaveE)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveE
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveE = L -> false
============================
 false

 < AppE: apply fresh_name_start to _ Pr3.

Subgoal 1.4:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2 S1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveE (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveE (cons (head (name L)) (name SaveE))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveE))) (seq (assign L (cons (head (name SaveE)) (name L))) (assign SaveE (tail (name SaveE)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveE
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveE = L -> false
AppE : "E" ++ S1 = SaveE
============================
 false

 < AppH: apply fresh_name_start to _ Pr2.

Subgoal 1.4.1:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2 S1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveE (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveE (cons (head (name L)) (name SaveE))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveE))) (seq (assign L (cons (head (name SaveE)) (name L))) (assign SaveE (tail (name SaveE)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveE
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveE = L -> false
AppE : "E" ++ S1 = SaveE
============================
 is_string "Hold"

 < search 6.

Subgoal 1.4:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2 S1 S2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveE (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveE (cons (head (name L)) (name SaveE))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveE))) (seq (assign L (cons (head (name SaveE)) (name L))) (assign SaveE (tail (name SaveE)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveE
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveE = L -> false
AppE : "E" ++ S1 = SaveE
AppH : "Hold" ++ S2 = SaveE
============================
 false

 < case AppE.

Subgoal 1.4:

Variables: Names FE EE EE' O L SaveI E I LV VI O2 N V O3 LV2 S1 S2 L3
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy ("E"::L3) E) (seq (assign SaveI (name SaveI)) (seq (declare intTy ("E"::L3) (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign ("E"::L3) (cons (head (name L)) (name ("E"::L3)))) (assign L (tail (name L)))))) (seq (assign L (cons (name ("E"::L3)) (tail (name L)))) (while (not (null (name ("E"::L3)))) (seq (assign L (cons (head (name ("E"::L3))) (name L))) (assign ("E"::L3) (tail (name ("E"::L3))))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) ("E"::L3)
Pr3 : fresh_name "E" (L::Names) ("E"::L3)
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : "E"::L3 = L -> false
H2 : SaveI = L -> false
H3 : "E"::L3 = L -> false
AppH : "Hold" ++ S2 = "E"::L3
H4 : [] ++ S1 = L3
============================
 false

 < case AppH.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < assert Hold = SaveI -> false.

Subgoal 1.5:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
============================
 Hold = SaveI -> false

 < intros E.

Subgoal 1.5:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
E : Hold = SaveI
============================
 false

 < case E.

Subgoal 1.5:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveI (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveI (cons (head (name L)) (name SaveI))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveI))) (seq (assign L (cons (head (name SaveI)) (name L))) (assign SaveI (tail (name SaveI)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveI
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveI = L -> false
H4 : SaveI = SaveE -> false
============================
 false

 < AppI: apply fresh_name_start to _ Pr1.

Subgoal 1.5:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2 S1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveI (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveI (cons (head (name L)) (name SaveI))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveI))) (seq (assign L (cons (head (name SaveI)) (name L))) (assign SaveI (tail (name SaveI)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveI
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveI = L -> false
H4 : SaveI = SaveE -> false
AppI : "I" ++ S1 = SaveI
============================
 false

 < AppH: apply fresh_name_start to _ Pr2.

Subgoal 1.5.1:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2 S1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveI (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveI (cons (head (name L)) (name SaveI))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveI))) (seq (assign L (cons (head (name SaveI)) (name L))) (assign SaveI (tail (name SaveI)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveI
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveI = L -> false
H4 : SaveI = SaveE -> false
AppI : "I" ++ S1 = SaveI
============================
 is_string "Hold"

 < search 6.

Subgoal 1.5:

Variables: Names FE EE EE' O L SaveE SaveI E I LV VI O2 N V O3 LV2 S1 S2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy SaveI (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign SaveI (cons (head (name L)) (name SaveI))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name SaveI))) (seq (assign L (cons (head (name SaveI)) (name L))) (assign SaveI (tail (name SaveI)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) SaveI
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : SaveI = L -> false
H4 : SaveI = SaveE -> false
AppI : "I" ++ S1 = SaveI
AppH : "Hold" ++ S2 = SaveI
============================
 false

 < case AppI.

Subgoal 1.5:

Variables: Names FE EE EE' O L SaveE E I LV VI O2 N V O3 LV2 S1 S2 L3
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy ("I"::L3) I) (seq (declare intTy SaveE E) (seq (assign ("I"::L3) (name ("I"::L3))) (seq (declare intTy ("I"::L3) (nil intTy)) (seq (while (greater (name ("I"::L3)) (num 0)) (seq (assign ("I"::L3) (minus (name ("I"::L3)) (num 1))) (seq (assign ("I"::L3) (cons (head (name L)) (name ("I"::L3)))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name ("I"::L3)))) (seq (assign L (cons (head (name ("I"::L3))) (name L))) (assign ("I"::L3) (tail (name ("I"::L3))))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) ("I"::L3)
Pr2 : fresh_name "Hold" (L::Names) ("I"::L3)
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : "I"::L3 = L -> false
H3 : "I"::L3 = L -> false
H4 : "I"::L3 = SaveE -> false
AppH : "Hold" ++ S2 = "I"::L3
H5 : [] ++ S1 = L3
============================
 false

 < case AppH.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < NEqIE: assert SaveI = SaveE -> false.

Subgoal 1.6:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
============================
 SaveI = SaveE -> false

 < intros E.

Subgoal 1.6:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
E : SaveI = SaveE
============================
 false

 < case E.

Subgoal 1.6:

Variables: Names FE EE EE' O Hold L SaveE E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveE I) (seq (declare intTy SaveE E) (seq (assign SaveE (name SaveE)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveE) (num 0)) (seq (assign SaveE (minus (name SaveE) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveE
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveE = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveE -> false
============================
 false

 < AppI: apply fresh_name_start to _ Pr1.

Subgoal 1.6:

Variables: Names FE EE EE' O Hold L SaveE E I LV VI O2 N V O3 LV2 S1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveE I) (seq (declare intTy SaveE E) (seq (assign SaveE (name SaveE)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveE) (num 0)) (seq (assign SaveE (minus (name SaveE) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveE
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveE = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveE -> false
AppI : "I" ++ S1 = SaveE
============================
 false

 < AppE: apply fresh_name_start to _ Pr3.

Subgoal 1.6:

Variables: Names FE EE EE' O Hold L SaveE E I LV VI O2 N V O3 LV2 S1 S2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveE I) (seq (declare intTy SaveE E) (seq (assign SaveE (name SaveE)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveE) (num 0)) (seq (assign SaveE (minus (name SaveE) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveE
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveE = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveE -> false
AppI : "I" ++ S1 = SaveE
AppE : "E" ++ S2 = SaveE
============================
 false

 < case AppI.

Subgoal 1.6:

Variables: Names FE EE EE' O Hold L E I LV VI O2 N V O3 LV2 S1 S2 L3
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy ("I"::L3) I) (seq (declare intTy ("I"::L3) E) (seq (assign ("I"::L3) (name ("I"::L3))) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name ("I"::L3)) (num 0)) (seq (assign ("I"::L3) (minus (name ("I"::L3)) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name ("I"::L3)) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) ("I"::L3)
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) ("I"::L3)
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : "I"::L3 = L -> false
H2 : "I"::L3 = L -> false
H3 : Hold = L -> false
H4 : Hold = "I"::L3 -> false
H5 : Hold = "I"::L3 -> false
AppE : "E" ++ S2 = "I"::L3
H6 : [] ++ S1 = L3
============================
 false

 < case AppE.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < EvI: assert evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2.

Subgoal 1.7:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
============================
 evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < V: apply vars_exist to Is1.

Subgoal 1.7:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
V : vars I V1
============================
 evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < apply evalExpr_rel_exists to _ _ _ _ Ev1 V _ with
     EE_A = []::EE.

Subgoal 1.7:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
V : vars I V1
H6 : evalExpr FE ([]::EE) I VI O2
============================
 evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < search.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < apply fresh_name_is to _ Pr1.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < apply evalExpr_isValue to _ _ _ Ev1.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < EvE: assert evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3.

Subgoal 1.8:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
============================
 evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < V: apply vars_exist to Is2.

Subgoal 1.8:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
============================
 evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < apply evalExpr_rel_exists to _ _ _ _ Ev3 V _ with
     EE_A = [(SaveI, VI)]::EE.

Subgoal 1.8.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
============================
 forall X XV,
   mem X V1 -> lookupScopes X EE XV -> lookupScopes X ([(SaveI, VI)]::EE) XV

 < intros M L.

Subgoal 1.8.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1 X XV
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
M : mem X V1
L : lookupScopes X EE XV
============================
 lookupScopes X ([(SaveI, VI)]::EE) XV

 < MemN: apply lookupScopes_names to L Names.

Subgoal 1.8.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1 X XV
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
M : mem X V1
L : lookupScopes X EE XV
MemN : mem X Names
============================
 lookupScopes X ([(SaveI, VI)]::EE) XV

 < assert SaveI = X -> false.

Subgoal 1.8.1.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1 X XV
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
M : mem X V1
L : lookupScopes X EE XV
MemN : mem X Names
============================
 SaveI = X -> false

 < intros E.

Subgoal 1.8.1.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1 X XV
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
M : mem X V1
L : lookupScopes X EE XV
MemN : mem X Names
E : SaveI = X
============================
 false

 < case E.

Subgoal 1.8.1.1:

Variables: Names FE EE EE' O Hold L SaveE E I LV VI O2 N V O3 LV2 V1 X XV
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy X I) (seq (declare intTy SaveE E) (seq (assign X (name X)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name X) (num 0)) (seq (assign X (minus (name X) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) X
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : X = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = X -> false
NEqIE : X = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy X I) ([(X, VI)]::EE) O2
H6 : is_string X
H7 : is_value VI
V : vars E V1
M : mem X V1
L : lookupScopes X EE XV
MemN : mem X Names
============================
 false

 < apply fresh_name_not_mem to Pr1 _.

Subgoal 1.8.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1 X XV
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
M : mem X V1
L : lookupScopes X EE XV
MemN : mem X Names
H8 : SaveI = X -> false
============================
 lookupScopes X ([(SaveI, VI)]::EE) XV

 < search.

Subgoal 1.8:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 V1
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
V : vars E V1
H8 : evalExpr FE ([(SaveI, VI)]::EE) E V O3
============================
 evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < search.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < apply fresh_name_is to _ Pr3.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < apply evalExpr_isValue to _ _ _ Ev3.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < EvAI: assert evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) [].

Subgoal 1.9:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
============================
 evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []

 < assert SaveE = SaveI -> false.

Subgoal 1.9.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
============================
 SaveE = SaveI -> false

 < intros E.

Subgoal 1.9.1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
E : SaveE = SaveI
============================
 false

 < case E.

Subgoal 1.9.1:

Variables: Names FE EE EE' O Hold L SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveI E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveI) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveI
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveI = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveI -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveI -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveI E) ([(SaveI, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveI
H9 : is_value V
============================
 false

 < backchain NEqIE.

Subgoal 1.9:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
H10 : SaveE = SaveI -> false
============================
 evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []

 < search.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < EvH: assert evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (matchEval:list:nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) [].

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < IsSaveI: apply fresh_name_is to _ Pr1.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < IsHold: apply fresh_name_is to _ Pr2.

Subgoal 1.10:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
============================
 is_string "Hold"

 < search 6.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < GEq: apply updateListIndex_pos to Ev4.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < IsN: apply evalExpr_isValue to _ _ _ Ev1.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < Main: apply proj_listUpdate_eval to _ _ _ _ _ _ _ _ _ _ _ _ _ with
           OldL = LV
           I = N
           V = V
           NewL = LV2
           Hold = Hold
           VI = VI HoldL = nilVal SaveI = SaveI SaveE = SaveE G = EE L = L.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < apply drop_proj_rel_evalStmt to Main.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) EE'' O /\
   scopes_same EE' EE''

 < exists G'.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
============================
 evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) G' O /\
 scopes_same EE' G'

 < IsO3: apply evalExpr_isOutput to _ _ _ Ev3.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
IsO3 : is_list is_value O3
============================
 evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) G' O /\
 scopes_same EE' G'

 < apply is_list_values_append_nil to IsO3.

Subgoal 1:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
============================
 evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) G' O /\
 scopes_same EE' G'

 < split.

Subgoal 1.11:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
============================
 evalStmt FE EE (scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))) G' O

 < search 20.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV2 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV2
Ev5 : replaceScopes L LV2 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
============================
 scopes_same EE' G'

 < case Main3.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 G' LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV1
Ev5 : replaceScopes L LV1 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
============================
 scopes_same EE' G'

 < apply replaceScopes_unique to Main2 Ev5.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV1
Ev5 : replaceScopes L LV1 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE EE'
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
============================
 scopes_same EE' EE'

 < apply lookupScopes_is to _ Ev.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV1
Ev5 : replaceScopes L LV1 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE EE'
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
H12 : is_value LV
============================
 scopes_same EE' EE'

 < apply evalExpr_isValue to _ _ _ Ev3.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV1
Ev5 : replaceScopes L LV1 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE EE'
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
H12 : is_value LV
H13 : is_value V
============================
 scopes_same EE' EE'

 < apply updateListIndex_is to _ _ Ev4.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV1
Ev5 : replaceScopes L LV1 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE EE'
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
H12 : is_value LV
H13 : is_value V
H14 : is_value LV1
============================
 scopes_same EE' EE'

 < apply replaceScopes_is to _ _ Main2.

Subgoal 1.12:

Variables: Names FE EE EE' O Hold L SaveE SaveI E I LV VI O2 N V O3 LV1 VI'
Pr : Names |{stmt}- listUpdate L I E ~~> scopeStmt (seq (declare intTy SaveI I) (seq (declare intTy SaveE E) (seq (assign SaveI (name SaveI)) (seq (declare intTy Hold (nil intTy)) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold)))))))))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "I" (L::Names) SaveI
Pr2 : fresh_name "Hold" (L::Names) Hold
Pr3 : fresh_name "E" (L::Names) SaveE
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
Ev : lookupScopes L EE LV
Ev1 : evalExpr FE EE I VI O2
Ev2 : matchInt VI N
Ev3 : evalExpr FE EE E V O3
Ev4 : updateListIndex LV N V LV1
Ev5 : replaceScopes L LV1 EE EE'
Ev6 : O2 ++ O3 = O
H1 : SaveE = L -> false
H2 : SaveI = L -> false
H3 : Hold = L -> false
H4 : Hold = SaveE -> false
H5 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI : evalStmt FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
H6 : is_string SaveI
H7 : is_value VI
EvE : evalStmt FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H8 : is_string SaveE
H9 : is_value V
EvAI : evalStmt FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : evalStmt FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
IsSaveI : is_string SaveI
IsHold : is_string Hold
GEq : N >= 0
IsN : is_value VI
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE EE'
H10 : evalStmt FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::EE') []
IsO3 : is_list is_value O3
H11 : O3 ++ [] = O3
H12 : is_value LV
H13 : is_value V
H14 : is_value LV1
H15 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 scopes_same EE' EE'

 < backchain scopes_same_reflexive.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O
Pr1 : fresh_name "L" (X::Names) SaveL
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < Is: case IsS.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < Ev: case Ev.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < apply evalExpr_isValue to _ _ _ Ev.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < EvW: apply iterateList_to_while to _ _ _ _ _ Ev1 Names Pr1.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V'
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < V: apply vars_exist to _ with
        E = L.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V' V
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < Ev': apply evalExpr_rel_exists to _ _ _ _ Ev V _ with
          EE_A = []::EE.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V' V
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
Ev' : evalExpr FE ([]::EE) L LV O2
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < apply iterateList_isCtx to _ _ _ _ _ Ev1.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V' V
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
Ev' : evalExpr FE ([]::EE) L LV O2
H2 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 exists EE'',
   evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE'' O /\
   scopes_same EE' EE''

 < exists EE'.

Subgoal 2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V' V
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
Ev' : evalExpr FE ([]::EE) L LV O2
H2 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE' O /\
 scopes_same EE' EE'

 < split.

Subgoal 2.1:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V' V
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
Ev' : evalExpr FE ([]::EE) L LV O2
H2 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 evalStmt FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE' O

 < search.

Subgoal 2.2:

Variables: Names FE EE EE' O Body SaveL X L LV O2 O3 V' V
Pr : Names |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))
Names : names EE Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Pr1 : fresh_name "L" (X::Names) SaveL
Is : is_string X
Is1 : is_expr L
Is2 : is_stmt Body
Ev : evalExpr FE EE L LV O2
Ev1 : iterateList FE EE LV X Body EE' O3
Ev2 : O2 ++ O3 = O
H1 : is_value LV
EvW : evalStmt FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
Ev' : evalExpr FE ([]::EE) L LV O2
H2 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 scopes_same EE' EE'

 < backchain scopes_same_reflexive.

Proof completed.

 < Prove_Ext_Ind matchEval:host:evalExpr,
   matchEval:host:evalArgs,
   matchEval:host:evalRecFields,
   matchEval:host:evalStmt
   with forall FE EE V X Body EE' O, iterateList FE EE V X Body EE' O with
            IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE, IsEE : is_list (is_list (is_pair is_string is_value)) EE, IsV : is_value V, IsX : is_string X, IsBody : is_stmt Body.

Subgoal 1.32:

Variables: FE EE Ty
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (nil Ty) nilVal [] 1 @@
Acc : acc 1 @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (nil Ty)
============================
 <evalExpr {P}> FE EE (nil Ty) nilVal []

 < apply names_exists to IsEE.

Subgoal 1.32:

Variables: FE EE Ty N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (nil Ty) nilVal [] 1 @@
Acc : acc 1 @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (nil Ty)
H1 : names EE N1
============================
 <evalExpr {P}> FE EE (nil Ty) nilVal []

 < search.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (cons E1 E2)
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < apply names_exists to IsEE.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (cons E1 E2)
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < apply ext_size_is_int_evalExpr to R3.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (cons E1 E2)
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < apply ext_size_is_int_evalExpr to R4.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (cons E1 E2)
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < case IsE.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < apply plus_integer_is_integer to _ _ R2.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < apply ext_size_pos_evalExpr to R3.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < apply ext_size_pos_evalExpr to R4.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < Acc: case Acc.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < RP1: assert <evalExpr {P}> FE EE E1 V1 O2.

Subgoal 1.33.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < Or: apply lt_left to R2 _ _.

Subgoal 1.33.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
Or : N2 < N4 \/ N2 = N4
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < L': case Or.

Subgoal 1.33.1.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < L'': apply less_integer_transitive to L' L.

Subgoal 1.33.1.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
L'' : N2 < N
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < A2: apply Acc to _ L''.

Subgoal 1.33.1.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
L'' : N2 < N
A2 : acc N2 *
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < apply IH to R3 A2 _ _ _.

Subgoal 1.33.1.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
L'' : N2 < N
A2 : acc N2 *
H9 : <evalExpr {P}> FE EE E1 V1 O2
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < search.

Subgoal 1.33.1.2:

Variables: N FE EE O N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N4 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N4 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N4
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N4
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < A2: apply Acc to _ L.

Subgoal 1.33.1.2:

Variables: N FE EE O N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N4 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N4 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N4
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N4
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
A2 : acc N4 *
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < apply IH to R3 A2 _ _ _.

Subgoal 1.33.1.2:

Variables: N FE EE O N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N4 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N4 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N4
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N4
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
A2 : acc N4 *
H9 : <evalExpr {P}> FE EE E1 V1 O2
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < search.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < RP2: assert <evalExpr {P}> FE EE E2 V2 O3.

Subgoal 1.33.2:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < Or: apply lt_right to R2 _ _ _.

Subgoal 1.33.2:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
Or : N3 < N4 \/ N3 = N4
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < L': case Or.

Subgoal 1.33.2.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
L' : N3 < N4
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < L'': apply less_integer_transitive to L' L.

Subgoal 1.33.2.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
L' : N3 < N4
L'' : N3 < N
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < A3: apply Acc to _ L''.

Subgoal 1.33.2.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
L' : N3 < N4
L'' : N3 < N
A3 : acc N3 *
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < apply IH to R4 A3 _ _ _.

Subgoal 1.33.2.1:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
L' : N3 < N4
L'' : N3 < N
A3 : acc N3 *
H9 : <evalExpr {P}> FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < search.

Subgoal 1.33.2.2:

Variables: N FE EE O N2 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N4 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N4
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N4
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < A3: apply Acc to _ L.

Subgoal 1.33.2.2:

Variables: N FE EE O N2 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N4 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N4
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N4
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
A3 : acc N4 *
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < apply IH to R4 A3 _ _ _.

Subgoal 1.33.2.2:

Variables: N FE EE O N2 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N4 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N4
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N4
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
A3 : acc N4 *
H9 : <evalExpr {P}> FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < search.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE (cons E1 E2) (consVal V1 V2) O

 < unfold .

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 exists E_P V_P O_P O1 O2,
   (<evalExpr {P}> FE EE E1 V1 O1 /\
   (<evalExpr {P}> FE EE E2 V2 O2 /\ O1 ++ O2 = O)) /\
   (|{expr}- cons E1 E2 ~~> E_P /\ <evalExpr {P}> FE EE E_P V_P O_P)

 < exists recBuild (consRecFieldExprs "null" matchEval:host:false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs))),
   recVal [("null", falseVal), ("head", V1), ("tail", V2)],
   O,
   O2,
   O3.

Subgoal 1.33:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 (<evalExpr {P}> FE EE E1 V1 O2 /\
 (<evalExpr {P}> FE EE E2 V2 O3 /\ O2 ++ O3 = O)) /\
 (|{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs))) /\
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O)

 < split.

Subgoal 1.33.3:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE E1 V1 O2

 < search.

Subgoal 1.33.4:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE E2 V2 O3

 < search.

Subgoal 1.33.5:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 O2 ++ O3 = O

 < search.

Subgoal 1.33.6:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 |{expr}- cons E1 E2 ~~> recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))

 < search.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < Ev1: apply drop_ext_size_evalExpr to R3.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
Ev1 : evalExpr FE EE E1 V1 O2
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < Ev2: apply drop_ext_size_evalExpr to R4.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
Ev1 : evalExpr FE EE E1 V1 O2
Ev2 : evalExpr FE EE E2 V2 O3
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < IsO2: apply evalExpr_isOutput to _ _ _ Ev1.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
Ev1 : evalExpr FE EE E1 V1 O2
Ev2 : evalExpr FE EE E2 V2 O3
IsO2 : is_list is_value O2
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < IsO3: apply evalExpr_isOutput to _ _ _ Ev2.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
Ev1 : evalExpr FE EE E1 V1 O2
Ev2 : evalExpr FE EE E2 V2 O3
IsO2 : is_list is_value O2
IsO3 : is_list is_value O3
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < apply is_list_values_append_nil to IsO2.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
Ev1 : evalExpr FE EE E1 V1 O2
Ev2 : evalExpr FE EE E2 V2 O3
IsO2 : is_list is_value O2
IsO3 : is_list is_value O3
H9 : O2 ++ [] = O2
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < apply is_list_values_append_nil to IsO3.

Subgoal 1.33.7:

Variables: N FE EE O N2 N3 N4 O2 O3 V2 V1 E2 E1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (cons E1 E2) (consVal V1 V2) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE E1 V1 O2 N2 **
R4 : <evalExpr {ES}> FE EE E2 V2 O3 N3 **
R5 : O2 ++ O3 = O
H1 : names EE N1
H2 : is_integer N2
H3 : is_integer N3
H4 : is_expr E1
H5 : is_expr E2
H6 : is_integer N4
L : N4 < N
H7 : 0 <= N2
H8 : 0 <= N3
Acc : forall M, 0 <= M -> M < N -> acc M *
RP1 : <evalExpr {P}> FE EE E1 V1 O2
RP2 : <evalExpr {P}> FE EE E2 V2 O3
Ev1 : evalExpr FE EE E1 V1 O2
Ev2 : evalExpr FE EE E2 V2 O3
IsO2 : is_list is_value O2
IsO3 : is_list is_value O3
H9 : O2 ++ [] = O2
H10 : O3 ++ [] = O3
============================
 <evalExpr {P}> FE EE (recBuild (consRecFieldExprs "null" false (consRecFieldExprs "head" E1 (consRecFieldExprs "tail" E2 nilRecFieldExprs)))) (recVal [("null", falseVal), ("head", V1), ("tail", V2)]) O

 < search.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (head E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
============================
 <evalExpr {P}> FE EE (head E1) V O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (head E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
============================
 <evalExpr {P}> FE EE (head E1) V O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (head E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
============================
 <evalExpr {P}> FE EE (head E1) V O

 < case IsE.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
============================
 <evalExpr {P}> FE EE (head E1) V O

 < Acc: case Acc.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (head E1) V O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
============================
 <evalExpr {P}> FE EE (head E1) V O

 < A: apply Acc to _ L.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
============================
 <evalExpr {P}> FE EE (head E1) V O

 < apply IH to R2 A _ _ _.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal V Tl) O
============================
 <evalExpr {P}> FE EE (head E1) V O

 < Ev: apply drop_ext_size_evalExpr to R2.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal V Tl) O
Ev : evalExpr FE EE E1 (consVal V Tl) O
============================
 <evalExpr {P}> FE EE (head E1) V O

 < IsO: apply evalExpr_isOutput to _ _ _ Ev.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal V Tl) O
Ev : evalExpr FE EE E1 (consVal V Tl) O
IsO : is_list is_value O
============================
 <evalExpr {P}> FE EE (head E1) V O

 < apply is_list_values_append_nil to IsO.

Subgoal 1.34:

Variables: N FE EE V O N2 Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (head E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal V Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal V Tl) O
Ev : evalExpr FE EE E1 (consVal V Tl) O
IsO : is_list is_value O
H5 : O ++ [] = O
============================
 <evalExpr {P}> FE EE (head E1) V O

 < search.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (tail E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (tail E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (tail E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < case IsE.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < Acc: case Acc.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < A: apply Acc to _ L.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < apply IH to R2 A _ _ _.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd V) O
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < Ev: apply drop_ext_size_evalExpr to R2.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd V) O
Ev : evalExpr FE EE E1 (consVal Hd V) O
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < IsO: apply evalExpr_isOutput to _ _ _ Ev.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd V) O
Ev : evalExpr FE EE E1 (consVal Hd V) O
IsO : is_list is_value O
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < apply is_list_values_append_nil to IsO.

Subgoal 1.35:

Variables: N FE EE V O N2 Hd E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (tail E1) V O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd V) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd V) O
Ev : evalExpr FE EE E1 (consVal Hd V) O
IsO : is_list is_value O
H5 : O ++ [] = O
============================
 <evalExpr {P}> FE EE (tail E1) V O

 < search.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (null E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (null E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (null E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < case IsE.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < Acc: case Acc.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < A: apply Acc to _ L.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < apply IH to R2 A _ _ _.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 nilVal O
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < Ev: apply drop_ext_size_evalExpr to R2.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 nilVal O
Ev : evalExpr FE EE E1 nilVal O
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < IsO: apply evalExpr_isOutput to _ _ _ Ev.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 nilVal O
Ev : evalExpr FE EE E1 nilVal O
IsO : is_list is_value O
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < apply is_list_values_append_nil to IsO.

Subgoal 1.36:

Variables: N FE EE O N2 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) trueVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 nilVal O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 nilVal O
Ev : evalExpr FE EE E1 nilVal O
IsO : is_list is_value O
H5 : O ++ [] = O
============================
 <evalExpr {P}> FE EE (null E1) trueVal O

 < search.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (null E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (null E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (null E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < case IsE.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < Acc: case Acc.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < A: apply Acc to _ L.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < apply IH to R2 A _ _ _.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd Tl) O
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < Ev: apply drop_ext_size_evalExpr to R2.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd Tl) O
Ev : evalExpr FE EE E1 (consVal Hd Tl) O
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < IsO: apply evalExpr_isOutput to _ _ _ Ev.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd Tl) O
Ev : evalExpr FE EE E1 (consVal Hd Tl) O
IsO : is_list is_value O
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < apply is_list_values_append_nil to IsO.

Subgoal 1.37:

Variables: N FE EE O N2 Hd Tl E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalExpr {ES}> FE EE (null E1) falseVal O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 (consVal Hd Tl) O N2 **
H1 : is_integer N2
H2 : 0 <= N2
H3 : is_expr E1
Acc : forall M, 0 <= M -> M < N -> acc M *
L : N2 < N
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 (consVal Hd Tl) O
Ev : evalExpr FE EE E1 (consVal Hd Tl) O
IsO : is_list is_value O
H5 : O ++ [] = O
============================
 <evalExpr {P}> FE EE (null E1) falseVal O

 < search.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsS : is_stmt (listUpdate L I E)
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < Is: case IsS.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply ext_size_is_int_evalExpr to R4.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply ext_size_is_int_evalExpr to R6.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply ext_size_pos_evalExpr to R4.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply ext_size_pos_evalExpr to R6.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply plus_integer_is_integer to _ _ R2.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < L4: apply lt_plus_one to R1 _.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < Acc': case Acc (keep).

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < L2: assert N2 < N.

Subgoal 4.15.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 N2 < N

 < Or: apply lt_right to R2 _ _ _.

Subgoal 4.15.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
Or : N2 < N4 \/ N2 = N4
============================
 N2 < N

 < L': case Or.

Subgoal 4.15.1.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
============================
 N2 < N

 < apply less_integer_transitive to L' L4.

Subgoal 4.15.1.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
H6 : N2 < N
============================
 N2 < N

 < search.

Subgoal 4.15.1.2:

Variables: N FE EE EE' O N3 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N4 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N4 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N4
H3 : 0 <= N3
H4 : 0 <= N4
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 N4 < N

 < search.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < L3: assert N3 < N.

Subgoal 4.15.2:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
============================
 N3 < N

 < Or: apply lt_left to R2 _ _.

Subgoal 4.15.2:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
Or : N3 < N4 \/ N3 = N4
============================
 N3 < N

 < L': case Or.

Subgoal 4.15.2.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L' : N3 < N4
============================
 N3 < N

 < apply less_integer_transitive to L' L4.

Subgoal 4.15.2.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L' : N3 < N4
H6 : N3 < N
============================
 N3 < N

 < search.

Subgoal 4.15.2.2:

Variables: N FE EE EE' O N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N4 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N4 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N4
H2 : is_integer N2
H3 : 0 <= N4
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
============================
 N4 < N

 < search.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < A2: apply Acc' to _ L2.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < A3: apply Acc' to _ L3.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvI: apply IH to R4 A3 _ _ _.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvE: apply IH to R6 A2 _ _ _.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvI': apply drop_ext_size_evalExpr to R4.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvE': apply drop_ext_size_evalExpr to R6.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply evalExpr_isValue to _ _ _ EvI'.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply evalExpr_isValue to _ _ _ EvE'.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < NamesEE: apply names_exists to IsEE.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L N5
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE N5
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < rename N5 to Names.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < IsNames: apply names_is to _ NamesEE.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < IsNames+: assert is_list is_string (L::Names).

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < FrI: apply fresh_name_exists to _ IsNames+ with
          Base = "I".

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < FrH: apply fresh_name_exists to _ IsNames+ with
          Base = "Hold".

Subgoal 4.15.3:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
============================
 is_string "Hold"

 < search 6.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F F1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
FrH : fresh_name "Hold" (L::Names) F1
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < FrE: apply fresh_name_exists to _ IsNames+ with
          Base = "E".

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F F1 F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
FrH : fresh_name "Hold" (L::Names) F1
FrE : fresh_name "E" (L::Names) F2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply fresh_name_is to _ FrI.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F F1 F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
FrH : fresh_name "Hold" (L::Names) F1
FrE : fresh_name "E" (L::Names) F2
H8 : is_string F
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply fresh_name_is to _ FrE.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F F1 F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
FrH : fresh_name "Hold" (L::Names) F1
FrE : fresh_name "E" (L::Names) F2
H8 : is_string F
H9 : is_string F2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply fresh_name_is to _ FrH.

Subgoal 4.15.4:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F F1 F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
FrH : fresh_name "Hold" (L::Names) F1
FrE : fresh_name "E" (L::Names) F2
H8 : is_string F
H9 : is_string F2
============================
 is_string "Hold"

 < search 6.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names F F1 F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) F
FrH : fresh_name "Hold" (L::Names) F1
FrE : fresh_name "E" (L::Names) F2
H8 : is_string F
H9 : is_string F2
H10 : is_string F1
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < rename F to SaveI.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI F1 F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) F1
FrE : fresh_name "E" (L::Names) F2
H8 : is_string SaveI
H9 : is_string F2
H10 : is_string F1
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < rename F1 to Hold.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold F2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) F2
H8 : is_string SaveI
H9 : is_string F2
H10 : is_string Hold
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < rename F2 to SaveE.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < assert SaveE = L -> false.

Subgoal 4.15.5:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
============================
 SaveE = L -> false

 < intros E.

Subgoal 4.15.5:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
E : SaveE = L
============================
 false

 < case E.

Subgoal 4.15.5:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) L
H8 : is_string SaveI
H9 : is_string L
H10 : is_string Hold
============================
 false

 < apply fresh_name_not_mem to FrE _.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < assert SaveI = L -> false.

Subgoal 4.15.6:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
============================
 SaveI = L -> false

 < intros E.

Subgoal 4.15.6:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
E : SaveI = L
============================
 false

 < case E.

Subgoal 4.15.6:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) L
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string L
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
============================
 false

 < apply fresh_name_not_mem to FrI _.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < assert Hold = L -> false.

Subgoal 4.15.7:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
============================
 Hold = L -> false

 < intros E.

Subgoal 4.15.7:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
E : Hold = L
============================
 false

 < case E.

Subgoal 4.15.7:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) L
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string L
H11 : SaveE = L -> false
H12 : SaveI = L -> false
============================
 false

 < apply fresh_name_not_mem to FrH _.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < assert Hold = SaveE -> false.

Subgoal 4.15.8:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
============================
 Hold = SaveE -> false

 < intros E.

Subgoal 4.15.8:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
E : Hold = SaveE
============================
 false

 < case E.

Subgoal 4.15.8:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveE
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveE
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveE = L -> false
============================
 false

 < AppE: apply fresh_name_start to _ FrE.

Subgoal 4.15.8:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE S1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveE
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveE
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveE = L -> false
AppE : "E" ++ S1 = SaveE
============================
 false

 < AppH: apply fresh_name_start to _ FrH.

Subgoal 4.15.8.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE S1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveE
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveE
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveE = L -> false
AppE : "E" ++ S1 = SaveE
============================
 is_string "Hold"

 < search 6.

Subgoal 4.15.8:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE S1 S2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveE
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveE
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveE = L -> false
AppE : "E" ++ S1 = SaveE
AppH : "Hold" ++ S2 = SaveE
============================
 false

 < case AppE.

Subgoal 4.15.8:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI S1 S2 L3
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) ("E"::L3)
FrE : fresh_name "E" (L::Names) ("E"::L3)
H8 : is_string SaveI
H9 : is_string ("E"::L3)
H10 : is_string ("E"::L3)
H11 : "E"::L3 = L -> false
H12 : SaveI = L -> false
H13 : "E"::L3 = L -> false
AppH : "Hold" ++ S2 = "E"::L3
H14 : [] ++ S1 = L3
============================
 false

 < case AppH.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < assert Hold = SaveI -> false.

Subgoal 4.15.9:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
============================
 Hold = SaveI -> false

 < intros E.

Subgoal 4.15.9:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
E : Hold = SaveI
============================
 false

 < case E.

Subgoal 4.15.9:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveI
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveI
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveI = L -> false
H14 : SaveI = SaveE -> false
============================
 false

 < AppI: apply fresh_name_start to _ FrI.

Subgoal 4.15.9:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE S1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveI
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveI
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveI = L -> false
H14 : SaveI = SaveE -> false
AppI : "I" ++ S1 = SaveI
============================
 false

 < AppH: apply fresh_name_start to _ FrH.

Subgoal 4.15.9.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE S1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveI
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveI
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveI = L -> false
H14 : SaveI = SaveE -> false
AppI : "I" ++ S1 = SaveI
============================
 is_string "Hold"

 < search 6.

Subgoal 4.15.9:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI SaveE S1 S2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) SaveI
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string SaveI
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : SaveI = L -> false
H14 : SaveI = SaveE -> false
AppI : "I" ++ S1 = SaveI
AppH : "Hold" ++ S2 = SaveI
============================
 false

 < case AppI.

Subgoal 4.15.9:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveE S1 S2 L3
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) ("I"::L3)
FrH : fresh_name "Hold" (L::Names) ("I"::L3)
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string ("I"::L3)
H9 : is_string SaveE
H10 : is_string ("I"::L3)
H11 : SaveE = L -> false
H12 : "I"::L3 = L -> false
H13 : "I"::L3 = L -> false
H14 : "I"::L3 = SaveE -> false
AppH : "Hold" ++ S2 = "I"::L3
H15 : [] ++ S1 = L3
============================
 false

 < case AppH.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < NEqIE: assert SaveI = SaveE -> false.

Subgoal 4.15.10:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
============================
 SaveI = SaveE -> false

 < intros E.

Subgoal 4.15.10:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
E : SaveI = SaveE
============================
 false

 < case E.

Subgoal 4.15.10:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveE
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveE
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveE = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveE -> false
============================
 false

 < AppI: apply fresh_name_start to _ FrI.

Subgoal 4.15.10:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names Hold SaveE S1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveE
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveE
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveE = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveE -> false
AppI : "I" ++ S1 = SaveE
============================
 false

 < AppE: apply fresh_name_start to _ FrE.

Subgoal 4.15.10:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names Hold SaveE S1 S2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveE
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveE
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveE = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveE -> false
AppI : "I" ++ S1 = SaveE
AppE : "E" ++ S2 = SaveE
============================
 false

 < case AppI.

Subgoal 4.15.10:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names Hold S1 S2 L3
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) ("I"::L3)
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) ("I"::L3)
H8 : is_string ("I"::L3)
H9 : is_string ("I"::L3)
H10 : is_string Hold
H11 : "I"::L3 = L -> false
H12 : "I"::L3 = L -> false
H13 : Hold = L -> false
H14 : Hold = "I"::L3 -> false
H15 : Hold = "I"::L3 -> false
AppE : "E" ++ S2 = "I"::L3
H16 : [] ++ S1 = L3
============================
 false

 < case AppE.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvI: assert <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2.

Subgoal 4.15.11:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < V: apply vars_exist to Is1.

Subgoal 4.15.11:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
V : vars I V1
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < E: apply evalExpr_rel_exists_ES to _ _ _ _ R4 V _ with
        EE_A = []::EE.

Subgoal 4.15.11:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
V : vars I V1
E : <evalExpr {ES}> FE ([]::EE) I VI O2 N3
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < apply IH to E A3 _ _ _.

Subgoal 4.15.11:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
V : vars I V1
E : <evalExpr {ES}> FE ([]::EE) I VI O2 N3
H16 : <evalExpr {P}> FE ([]::EE) I VI O2
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2

 < search 10.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvE: assert <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3.

Subgoal 4.15.12:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
============================
 <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < V: apply vars_exist to Is2.

Subgoal 4.15.12:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
============================
 <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < E: apply evalExpr_rel_exists_ES to _ _ _ _ R6 V _ with
        EE_A = [(SaveI, VI)]::EE.

Subgoal 4.15.12.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
============================
 forall X V2,
   mem X V1 -> lookupScopes X EE V2 -> lookupScopes X ([(SaveI, VI)]::EE) V2

 < intros M L.

Subgoal 4.15.12.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1 X V2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
M : mem X V1
L : lookupScopes X EE V2
============================
 lookupScopes X ([(SaveI, VI)]::EE) V2

 < MemN: apply lookupScopes_names to L NamesEE.

Subgoal 4.15.12.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1 X V2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
M : mem X V1
L : lookupScopes X EE V2
MemN : mem X Names
============================
 lookupScopes X ([(SaveI, VI)]::EE) V2

 < assert SaveI = X -> false.

Subgoal 4.15.12.1.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1 X V2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
M : mem X V1
L : lookupScopes X EE V2
MemN : mem X Names
============================
 SaveI = X -> false

 < intros E.

Subgoal 4.15.12.1.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1 X V2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
M : mem X V1
L : lookupScopes X EE V2
MemN : mem X Names
E : SaveI = X
============================
 false

 < case E.

Subgoal 4.15.12.1.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names Hold SaveE V1 X V2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) X
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string X
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : X = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = X -> false
NEqIE : X = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy X I) ([(X, VI)]::EE) O2
V : vars E V1
M : mem X V1
L : lookupScopes X EE V2
MemN : mem X Names
============================
 false

 < apply fresh_name_not_mem to FrI _.

Subgoal 4.15.12.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1 X V2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
M : mem X V1
L : lookupScopes X EE V2
MemN : mem X Names
H16 : SaveI = X -> false
============================
 lookupScopes X ([(SaveI, VI)]::EE) V2

 < search.

Subgoal 4.15.12:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
E : <evalExpr {ES}> FE ([(SaveI, VI)]::EE) E V O3 N2
============================
 <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < apply IH to E A2 _ _ _.

Subgoal 4.15.12:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE V1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
V : vars E V1
E : <evalExpr {ES}> FE ([(SaveI, VI)]::EE) E V O3 N2
H16 : <evalExpr {P}> FE ([(SaveI, VI)]::EE) E V O3
============================
 <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3

 < search.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvAI: assert <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) [].

Subgoal 4.15.13:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
============================
 <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []

 < assert SaveE = SaveI -> false.

Subgoal 4.15.13.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
============================
 SaveE = SaveI -> false

 < intros E.

Subgoal 4.15.13.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
E : SaveE = SaveI
============================
 false

 < case E.

Subgoal 4.15.13.1:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveI
H8 : is_string SaveI
H9 : is_string SaveI
H10 : is_string Hold
H11 : SaveI = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveI -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveI -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveI E) ([(SaveI, V), (SaveI, VI)]::EE) O3
============================
 false

 < backchain NEqIE.

Subgoal 4.15.13:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
H16 : SaveE = SaveI -> false
============================
 <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []

 < search.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
EvAI : <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < EvH: assert <evalStmt {P}> FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (matchEval:list:nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) [].

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
EvAI : <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : <evalStmt {P}> FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < GEq: apply updateListIndex_pos to R7.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
EvAI : <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : <evalStmt {P}> FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
GEq : N1 >= 0
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < Main: apply proj_listUpdate_eval to _ _ _ _ _ _ _ _ _ _ _ _ _ with
           OldL = LV
           I = N1
           V = V
           NewL = LV2
           Hold = Hold
           VI = VI HoldL = nilVal SaveI = SaveI SaveE = SaveE G = EE L = L.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE G' LV1 VI'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
EvAI : <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : <evalStmt {P}> FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
GEq : N1 >= 0
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < IsO3: apply evalExpr_isOutput to _ _ _ EvE'.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE G' LV1 VI'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
EvAI : <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : <evalStmt {P}> FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
GEq : N1 >= 0
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
IsO3 : is_list is_value O3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < apply is_list_values_append_nil to IsO3.

Subgoal 4.15:

Variables: N FE EE EE' O N3 N2 N4 LV VI O2 N1 V O3 LV2 E I L Names SaveI Hold SaveE G' LV1 VI'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names1 N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names1 N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names1 -> fresh_name "L" (X::Names1) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listUpdate L I E) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N3 + N2 = N4
R3 : lookupScopes L EE LV
R4 : <evalExpr {ES}> FE EE I VI O2 N3 **
R5 : matchInt VI N1
R6 : <evalExpr {ES}> FE EE E V O3 N2 **
R7 : updateListIndex LV N1 V LV2
R8 : replaceScopes L LV2 EE EE'
R9 : O2 ++ O3 = O
Is : is_string L
Is1 : is_expr I
Is2 : is_expr E
H1 : is_integer N3
H2 : is_integer N2
H3 : 0 <= N3
H4 : 0 <= N2
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
A3 : acc N3 *
EvI : <evalExpr {P}> FE EE I VI O2
EvE : <evalExpr {P}> FE EE E V O3
EvI' : evalExpr FE EE I VI O2
EvE' : evalExpr FE EE E V O3
H6 : is_value VI
H7 : is_value V
NamesEE : names EE Names
IsNames : is_list is_string Names
IsNames+ : is_list is_string (L::Names)
FrI : fresh_name "I" (L::Names) SaveI
FrH : fresh_name "Hold" (L::Names) Hold
FrE : fresh_name "E" (L::Names) SaveE
H8 : is_string SaveI
H9 : is_string SaveE
H10 : is_string Hold
H11 : SaveE = L -> false
H12 : SaveI = L -> false
H13 : Hold = L -> false
H14 : Hold = SaveE -> false
H15 : Hold = SaveI -> false
NEqIE : SaveI = SaveE -> false
EvI1 : <evalStmt {P}> FE ([]::EE) (declare intTy SaveI I) ([(SaveI, VI)]::EE) O2
EvE1 : <evalStmt {P}> FE ([(SaveI, VI)]::EE) (declare intTy SaveE E) ([(SaveE, V), (SaveI, VI)]::EE) O3
EvAI : <evalStmt {P}> FE ([(SaveE, V), (SaveI, VI)]::EE) (assign SaveI (name SaveI)) ([(SaveI, VI), (SaveE, V)]::EE) []
EvH : <evalStmt {P}> FE ([(SaveI, VI), (SaveE, V)]::EE) (declare intTy Hold (nil intTy)) ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) []
GEq : N1 >= 0
Main : <evalStmt {P}> FE ([(Hold, nilVal), (SaveI, VI), (SaveE, V)]::EE) (seq (while (greater (name SaveI) (num 0)) (seq (assign SaveI (minus (name SaveI) (num 1))) (seq (assign Hold (cons (head (name L)) (name Hold))) (assign L (tail (name L)))))) (seq (assign L (cons (name SaveE) (tail (name L)))) (while (not (null (name Hold))) (seq (assign L (cons (head (name Hold)) (name L))) (assign Hold (tail (name Hold))))))) ([(Hold, nilVal), (SaveI, VI'), (SaveE, V)]::G') []
Main1 : matchInt VI' 0
Main2 : replaceScopes L LV1 EE G'
Main3 : flipOnto nilVal LV2 LV1
IsO3 : is_list is_value O3
H16 : O3 ++ [] = O3
============================
 <evalStmt {P}> FE EE (listUpdate L I E) EE' O

 < search 20.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsS : is_stmt (listForeach X L Body)
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < IsS: case IsS.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply ext_size_is_int_evalExpr to R3.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply ext_size_is_int_iterateList to R4.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply ext_size_pos_evalExpr to R3.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply ext_size_pos_iterateList to R4.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply plus_integer_is_integer to _ _ R2.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < L4: apply lt_plus_one to R1 _.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Acc': case Acc (keep).

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < L2: assert N2 < N.

Subgoal 4.16.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 N2 < N

 < Or: apply lt_left to R2 _ _.

Subgoal 4.16.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
Or : N2 < N4 \/ N2 = N4
============================
 N2 < N

 < L': case Or.

Subgoal 4.16.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
============================
 N2 < N

 < apply less_integer_transitive to L' L4.

Subgoal 4.16.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L' : N2 < N4
H6 : N2 < N
============================
 N2 < N

 < search.

Subgoal 4.16.1.2:

Variables: N FE EE EE' O N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N4 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N4 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N4
H2 : is_integer N3
H3 : 0 <= N4
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 N4 < N

 < search.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < L3: assert N3 < N.

Subgoal 4.16.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
============================
 N3 < N

 < Or: apply lt_right to R2 _ _ _.

Subgoal 4.16.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
Or : N3 < N4 \/ N3 = N4
============================
 N3 < N

 < L': case Or.

Subgoal 4.16.2.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L' : N3 < N4
============================
 N3 < N

 < apply less_integer_transitive to L' L4.

Subgoal 4.16.2.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L' : N3 < N4
H6 : N3 < N
============================
 N3 < N

 < search.

Subgoal 4.16.2.2:

Variables: N FE EE EE' O N2 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N4 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N4
H3 : 0 <= N2
H4 : 0 <= N4
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
============================
 N4 < N

 < search.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < A2: apply Acc' to _ L2.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply IH to R3 A2 _ _ _.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Ev: apply drop_ext_size_evalExpr to R3.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply evalExpr_isValue to _ _ _ Ev.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < A3: apply Acc' to _ L3.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < ILP: apply IH10 to R4 A3 _ _ _ _ _.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < EvE: apply drop_ext_size_evalExpr to R3.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Names: apply names_exists to IsEE.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < IsN1: apply names_is to _ Names.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Fr: apply fresh_name_exists to _ _ with
         Base = "L" Names = X::N1.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 F
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) F
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < LenEE: apply length_exists_list_pair_string_value to IsEE.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 F N5
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) F
LenEE : length EE N5
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < rename F to SaveL.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL N5
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE N5
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < rename N5 to Len.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < NNS: assert newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE.

Subgoal 4.16.3:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE

 < unfold .

Subgoal 4.16.3:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 exists N SNames BNames,
   ((((length EE Len /\ drop N ([(SaveL, LV)]::EE) EE) /\
   take N ([(SaveL, LV)]::EE) [[(SaveL, LV)]]) /\
   names [[(SaveL, LV)]] SNames) /\
   names EE BNames) /\
   (forall X, mem X SNames -> mem X BNames -> false)

 < exists 1,
   [SaveL],
   N1.

Subgoal 4.16.3:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 ((((length EE Len /\ drop 1 ([(SaveL, LV)]::EE) EE) /\
 take 1 ([(SaveL, LV)]::EE) [[(SaveL, LV)]]) /\
 names [[(SaveL, LV)]] [SaveL]) /\
 names EE N1) /\
 (forall X, mem X [SaveL] -> mem X N1 -> false)

 < split.

Subgoal 4.16.3.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 length EE Len

 < search.

Subgoal 4.16.3.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 drop 1 ([(SaveL, LV)]::EE) EE

 < search.

Subgoal 4.16.3.3:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 take 1 ([(SaveL, LV)]::EE) [[(SaveL, LV)]]

 < search.

Subgoal 4.16.3.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 names [[(SaveL, LV)]] [SaveL]

 < search.

Subgoal 4.16.3.5:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 names EE N1

 < search.

Subgoal 4.16.3.6:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
============================
 forall X, mem X [SaveL] -> mem X N1 -> false

 < intros MSL MX.

Subgoal 4.16.3.6:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
MSL : mem X1 [SaveL]
MX : mem X1 N1
============================
 false

 < MSL: case MSL.

Subgoal 4.16.3.6.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
MX : mem SaveL N1
============================
 false

 < apply fresh_name_not_mem to Fr _.

Subgoal 4.16.3.6.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
MX : mem X1 N1
MSL : mem X1 []
============================
 false

 < case MSL.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply fresh_name_is to _ Fr.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < ILP': apply iterateList_newNameScopes_exists_ES to _ _ _ _ _ _ R4 NNS.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3 N3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < IL: apply drop_ext_size_iterateList to R4.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3 N3
IL : iterateList FE EE LV X Body EE' O3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < IL': apply drop_ext_size_iterateList to ILP'.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < NNS': apply iterateList_newNameScopes to _ _ _ _ _ _ IL' IL NNS.

Subgoal 4.16:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3
NNS' : newNameScopes [[(SaveL, LV)]] Len EE_A' EE'
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < NNS': case NNS'.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len EE_A' N5 SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body EE_A' O3
NNS' : length EE' Len
NNS'1 : drop N5 EE_A' EE'
NNS'2 : take N5 EE_A' [[(SaveL, LV)]]
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Take: case NNS'2.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len N5 SNames BNames N6 L1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'1 : drop N5 ([(SaveL, LV)]::L1) EE'
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + N6 = N5
Take1 : take N6 L1 []
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < case Take1.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len N5 SNames BNames L1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'1 : drop N5 ([(SaveL, LV)]::L1) EE'
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = N5
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < compute Take.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'1 : drop 1 ([(SaveL, LV)]::L1) EE'
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Drop: case NNS'1.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L1 N7
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N7 = 1
Drop1 : drop N7 L1 EE'
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < IsN8: apply drop_is_integer to Drop1.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L1 N7
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N7 = 1
Drop1 : drop N7 L1 EE'
IsN8 : is_integer N7
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < apply plus_integer_unique_addend to _ _ _ Take Drop.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 EE'
IsN8 : is_integer 0
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Eq: assert L1 = EE'.

Subgoal 4.16.4.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 EE'
IsN8 : is_integer 0
============================
 L1 = EE'

 < D: case Drop1.

Subgoal 4.16.4.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
============================
 EE' = EE'

 < search.

Subgoal 4.16.4.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 L2 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
D : 1 + N8 = 0
D1 : drop N8 L2 EE'
============================
 X1::L2 = EE'

 < GEq: apply drop_geq_0 to D1.

Subgoal 4.16.4.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 L2 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
D : 1 + N8 = 0
D1 : drop N8 L2 EE'
GEq : N8 >= 0
============================
 X1::L2 = EE'

 < apply drop_is_integer to D1.

Subgoal 4.16.4.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 L2 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
D : 1 + N8 = 0
D1 : drop N8 L2 EE'
GEq : N8 >= 0
H9 : is_integer N8
============================
 X1::L2 = EE'

 < P: assert 1 + -1 = 0.

Subgoal 4.16.4.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 L2 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
D : 1 + N8 = 0
D1 : drop N8 L2 EE'
GEq : N8 >= 0
H9 : is_integer N8
P : 1 + -1 = 0
============================
 X1::L2 = EE'

 < apply plus_integer_unique_addend to _ _ _ P D.

Subgoal 4.16.4.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L2 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 EE'
GEq : -1 >= 0
H9 : is_integer -1
P : 1 + -1 = 0
============================
 X1::L2 = EE'

 < LEq: case GEq.

Subgoal 4.16.4.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L2 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::(X1::L2)) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
IsN8 : is_integer 0
D : 1 + -1 = 0
D1 : drop -1 L2 EE'
H9 : is_integer -1
P : 1 + -1 = 0
LEq : 0 <= -1
============================
 X1::L2 = EE'

 < case LEq.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames L1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::L1) O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L1 EE'
IsN8 : is_integer 0
Eq : L1 = EE'
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < case Eq.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 EE' EE'
IsN8 : is_integer 0
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < clear Take
   Drop
   Drop1
   IsN8.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < ILP'': apply IH4 to ILP' A3 _ _ _ _ _.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < Plus: apply plus_integer_total to _ _ with
           N1 = 1 N2 = N3.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < EvWP: assert exists V',
     <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3.

Subgoal 4.16.4.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < Or: apply lt_right to R2 _ _ _.

Subgoal 4.16.4.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
Or : N3 < N4 \/ N3 = N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < L: case Or.

Subgoal 4.16.4.2.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < LEq: apply less_integer_step_lesseq to _ _ L Plus.

Subgoal 4.16.4.2.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < Or: apply lesseq_integer_less_or_eq to LEq.

Subgoal 4.16.4.2.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
Or : N8 < N4 \/ N8 = N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < L': case Or.

Subgoal 4.16.4.2.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
L' : N8 < N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < L9: apply less_integer_transitive to L' L4.

Subgoal 4.16.4.2.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
L' : N8 < N4
L9 : N8 < N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < apply lesseq_integer__add_positive to _ _ Plus with
     Base = 0.

Subgoal 4.16.4.2.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
L' : N8 < N4
L9 : N8 < N
H9 : 0 <= N8
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < A9: apply Acc' to _ L9.

Subgoal 4.16.4.2.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
L' : N8 < N4
L9 : N8 < N
H9 : 0 <= N8
A9 : acc N8 *
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < apply IH_IL_W to _ _ _ _ _ R4 Plus A9 Names Fr.

Subgoal 4.16.4.2.1.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
L : N3 < N4
LEq : N8 <= N4
L' : N8 < N4
L9 : N8 < N
H9 : 0 <= N8
A9 : acc N8 *
H10 : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < search.

Subgoal 4.16.4.2.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N4
L : N3 < N4
LEq : N4 <= N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < apply lesseq_integer__add_positive to _ _ R2 with
     Base = 0.

Subgoal 4.16.4.2.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N4
L : N3 < N4
LEq : N4 <= N4
H9 : 0 <= N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < A4: apply Acc' to _ L4.

Subgoal 4.16.4.2.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N4
L : N3 < N4
LEq : N4 <= N4
H9 : 0 <= N4
A4 : acc N4 *
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < apply IH_IL_W to _ _ _ _ _ R4 Plus A4 Names Fr.

Subgoal 4.16.4.2.1.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N4
L : N3 < N4
LEq : N4 <= N4
H9 : 0 <= N4
A4 : acc N4 *
H10 : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < search.

Subgoal 4.16.4.2.2:

Variables: N FE EE EE' O N2 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N4 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N4
H3 : 0 <= N2
H4 : 0 <= N4
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N4 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N4 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N4
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N4 = N8
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < apply plus_integer_unique to Plus R1.

Subgoal 4.16.4.2.2:

Variables: N FE EE EE' O N2 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N4 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N4
H3 : 0 <= N2
H4 : 0 <= N4
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N4 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N4 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N4
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N4 = N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < apply IH_IL_W to _ _ _ _ _ R4 Plus Acc Names Fr.

Subgoal 4.16.4.2.2:

Variables: N FE EE EE' O N2 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N4 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N4 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N4
H3 : 0 <= N2
H4 : 0 <= N4
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N4 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N4 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N4
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N4 = N
H9 : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < search.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : exists V',
         <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < EvWP: case EvWP.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < V: apply vars_exist to IsS1.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < EvE+: apply evalExpr_rel_exists_ES to _ _ _ _ R3 V _ with
           EE_A = []::EE.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < EvE+': apply drop_ext_size_evalExpr to EvE+.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE EE (listForeach X L Body) EE' O

 < unfold .

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 exists Names S_P EE_P O_P LV O1 O2,
   (<evalExpr {P}> FE EE L LV O1 /\
   (<iterateList {P}> FE EE LV X Body EE' O2 /\ O1 ++ O2 = O)) /\
   (names EE Names /\
   (Names |{stmt}- listForeach X L Body ~~> S_P /\
   <evalStmt {P}> FE EE S_P EE_P O_P))

 < exists N1,
   scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))),
   EE',
   O,
   LV,
   O2,
   O3.

Subgoal 4.16.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 (<evalExpr {P}> FE EE L LV O2 /\
 (<iterateList {P}> FE EE LV X Body EE' O3 /\ O2 ++ O3 = O)) /\
 (names EE N1 /\
 (N1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))) /\
 <evalStmt {P}> FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE' O))

 < split.

Subgoal 4.16.4.3:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalExpr {P}> FE EE L LV O2

 < search.

Subgoal 4.16.4.4:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <iterateList {P}> FE EE LV X Body EE' O3

 < search.

Subgoal 4.16.4.5:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 O2 ++ O3 = O

 < search.

Subgoal 4.16.4.6:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 names EE N1

 < search.

Subgoal 4.16.4.7:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 N1 |{stmt}- listForeach X L Body ~~> scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))

 < search.

Subgoal 4.16.4.8:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE EE (scopeStmt (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))))) EE' O

 < unfold .

Subgoal 4.16.4.8:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 exists Scope,
   <evalStmt {P}> FE ([]::EE) (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))) (Scope::EE') O

 < exists [(SaveL, V')].

Subgoal 4.16.4.8:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE ([]::EE) (seq (declare intTy SaveL L) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body)))) ([(SaveL, V')]::EE') O

 < unfold .

Subgoal 4.16.4.8:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 exists EE1 O1 O2,
   <evalStmt {P}> FE ([]::EE) (declare intTy SaveL L) EE1 O1 /\
   (<evalStmt {P}> FE EE1 (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O2 /\
   O1 ++ O2 = O)

 < exists [(SaveL, LV)]::EE,
   O2,
   O3.

Subgoal 4.16.4.8:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveL L) ([(SaveL, LV)]::EE) O2 /\
 (<evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3 /\
 O2 ++ O3 = O)

 < split.

Subgoal 4.16.4.8.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveL L) ([(SaveL, LV)]::EE) O2

 < apply IH to EvE+ A2 _ _ _.

Subgoal 4.16.4.8.1:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
H9 : <evalExpr {P}> FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE ([]::EE) (declare intTy SaveL L) ([(SaveL, LV)]::EE) O2

 < search.

Subgoal 4.16.4.8.2:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3

 < search.

Subgoal 4.16.4.8.3:

Variables: N FE EE EE' O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len SNames BNames N8 V' V
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body EE' O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body EE' O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3 N3
IL : iterateList FE EE LV X Body EE' O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
NNS' : length EE' Len
NNS'3 : names [[(SaveL, LV)]] SNames
NNS'4 : names EE' BNames
NNS'5 : forall X, mem X SNames -> mem X BNames -> false
ILP'' : <iterateList {P}> FE ([(SaveL, LV)]::EE) LV X Body ([(SaveL, LV)]::EE') O3
Plus : 1 + N3 = N8
EvWP : <evalStmt {P}> FE ([(SaveL, LV)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
V : vars L V
EvE+ : <evalExpr {ES}> FE ([]::EE) L LV O2 N2
EvE+' : evalExpr FE ([]::EE) L LV O2
============================
 O2 ++ O3 = O

 < search.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < NSI: apply iterateList_names_same to _ _ _ _ _ IL.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
NSI : names_same EE (S1::BR)
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < LenBR+: apply names_same_length to NSI LenEE.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
NSI : names_same EE (S1::BR)
LenBR+ : length (S1::BR) Len
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < LenBR: case LenBR+.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR N'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
NSI : names_same EE (S1::BR)
LenBR : length BR N'
LenBR1 : 1 + N' = Len
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < apply length_is to LenBR.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR N'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
NSI : names_same EE (S1::BR)
LenBR : length BR N'
LenBR1 : 1 + N' = Len
H9 : is_integer N'
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < L: apply lt_plus_one to LenBR1 _.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR N'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
NSI : names_same EE (S1::BR)
LenBR : length BR N'
LenBR1 : 1 + N' = Len
H9 : is_integer N'
L : N' < Len
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < LEq: apply newNameScopes_length to NNS' LenBR.

Subgoal 4.16.5:

Variables: N FE EE O N2 N3 N4 LV O2 O3 Body L X N1 SaveL Len BR S1 AR N'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL1 V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
              exists V',
                <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL1 V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL1, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL1 ->
            exists V',
              <evalStmt {P}> FE ([(SaveL1, V)]::EE) (while (not (null (name SaveL1))) (seq (declare intTy X (head (name SaveL1))) (seq (assign SaveL1 (tail (name SaveL1))) Body))) ([(SaveL1, V')]::EE') O
R : <evalStmt {ES}> FE EE (listForeach X L Body) (S1::BR) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N4 = N
R2 : N2 + N3 = N4
R3 : <evalExpr {ES}> FE EE L LV O2 N2 **
R4 : <iterateList {ES}> FE EE LV X Body (S1::BR) O3 N3 **
R5 : O2 ++ O3 = O
IsS : is_string X
IsS1 : is_expr L
IsS2 : is_stmt Body
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
H5 : is_integer N4
L4 : N4 < N
Acc' : forall M, 0 <= M -> M < N -> acc M *
L2 : N2 < N
L3 : N3 < N
A2 : acc N2 *
H6 : <evalExpr {P}> FE EE L LV O2
Ev : evalExpr FE EE L LV O2
H7 : is_value LV
A3 : acc N3 *
ILP : <iterateList {P}> FE EE LV X Body (S1::BR) O3
EvE : evalExpr FE EE L LV O2
Names : names EE N1
IsN1 : is_list is_string N1
Fr : fresh_name "L" (X::N1) SaveL
LenEE : length EE Len
NNS : newNameScopes [[(SaveL, LV)]] Len ([(SaveL, LV)]::EE) EE
H8 : is_string SaveL
ILP' : <iterateList {ES}> FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3 N3
IL : iterateList FE EE LV X Body (S1::BR) O3
IL' : iterateList FE ([(SaveL, LV)]::EE) LV X Body (S1::AR) O3
NNS' : newNameScopes [[(SaveL, LV)]] Len AR BR
NSI : names_same EE (S1::BR)
LenBR : length BR N'
LenBR1 : 1 + N' = Len
H9 : is_integer N'
L : N' < Len
LEq : Len <= N'
============================
 <evalStmt {P}> FE EE (listForeach X L Body) (S1::BR) O

 < apply less_lesseq_flip_false to L LEq.

Subgoal 5.1:

Variables: FE X Body EE'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE' nilVal X Body EE' [] 0 @@
Acc : acc 0 @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
============================
 <iterateList {P}> FE EE' nilVal X Body EE' []

 < search.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < case IsV.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < Ev: apply drop_ext_size_evalStmt to R2.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < IL: apply drop_ext_size_iterateList to R3.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < apply ext_size_is_int_evalStmt to R2.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < apply ext_size_is_int_iterateList to R3.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < apply plus_integer_is_integer to _ _ R1.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < Acc': case Acc (keep).

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < apply ext_size_pos_evalStmt to R2.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < apply ext_size_pos_iterateList to R3.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < assert <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2.

Subgoal 5.2.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < Or: apply lt_left to R1 _ _.

Subgoal 5.2.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
Or : N2 < N \/ N2 = N
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < L': case Or.

Subgoal 5.2.1.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
L' : N2 < N
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < A2: apply Acc' to _ L'.

Subgoal 5.2.1.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
L' : N2 < N
A2 : acc N2 *
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < apply IH9 to R2 A2 _ _ _.

Subgoal 5.2.1.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
L' : N2 < N
A2 : acc N2 *
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < search.

Subgoal 5.2.1.2:

Variables: N FE EE X Body EE' O N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N
H7 : 0 <= N3
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < apply IH9 to R2 Acc _ _ _.

Subgoal 5.2.1.2:

Variables: N FE EE X Body EE' O N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2

 < search.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < assert <iterateList {P}> FE EE3 Tl X Body EE' O3.

Subgoal 5.2.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < IsEE3+: apply evalStmt_isCtx to _ _ _ Ev.

Subgoal 5.2.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IsEE3+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < case IsEE3+.

Subgoal 5.2.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < Or: apply lt_right to R1 _ _ _.

Subgoal 5.2.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
Or : N3 < N \/ N3 = N
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < L': case Or.

Subgoal 5.2.2.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
L' : N3 < N
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < A3: apply Acc' to _ L'.

Subgoal 5.2.2.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
L' : N3 < N
A3 : acc N3 *
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < apply IH10 to R3 A3 _ _ _ _ _.

Subgoal 5.2.2.1:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
L' : N3 < N
A3 : acc N3 *
H11 : <iterateList {P}> FE EE3 Tl X Body EE' O3
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < search.

Subgoal 5.2.2.2:

Variables: N FE EE X Body EE' O N2 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < apply IH10 to R3 Acc _ _ _ _ _.

Subgoal 5.2.2.2:

Variables: N FE EE X Body EE' O N2 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
H11 : <iterateList {P}> FE EE3 Tl X Body EE' O3
============================
 <iterateList {P}> FE EE3 Tl X Body EE' O3

 < search.

Subgoal 5.2:

Variables: N FE EE X Body EE' O N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
R : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsX : is_string X
IsBody : is_stmt Body
R1 : N2 + N3 = N
R2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
R3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
R4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
Ev : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
IL : iterateList FE EE3 Tl X Body EE' O3
H3 : is_integer N2
H4 : is_integer N3
H5 : is_integer N
Acc' : forall M, 0 <= M -> M < N -> acc M *
H6 : 0 <= N2
H7 : 0 <= N3
H8 : <evalStmt {P}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
H9 : <iterateList {P}> FE EE3 Tl X Body EE' O3
============================
 <iterateList {P}> FE EE (consVal Hd Tl) X Body EE' O

 < search.

Subgoal 6.1:

Variables: FE SaveL X Body EE' Names N'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, nilVal)]::EE')
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE' nilVal X Body EE' [] 0 @@
Plus : 1 + 0 = N'
Acc : acc N' @
Names : names EE' Names
Fr : fresh_name "L" (X::Names) SaveL
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, nilVal)]::EE') (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') []

 < search 20.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < case IsV.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < assert <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal [].

Subgoal 6.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []

 < search 20.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < assert <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) [].

Subgoal 6.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
============================
 <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []

 < search 20.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < NEq: assert X = SaveL -> false.

Subgoal 6.2.3:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
============================
 X = SaveL -> false

 < intros E.

Subgoal 6.2.3:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
E : X = SaveL
============================
 false

 < case E.

Subgoal 6.2.3:

Variables: FE SaveL EE Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string SaveL
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) SaveL Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (SaveL::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(SaveL, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl SaveL Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy SaveL (head (name SaveL))) ([(SaveL, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
============================
 false

 < apply fresh_name_not_mem to Fr _.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < assert <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) [].

Subgoal 6.2.4:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []

 < search 20.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < IsSaveL: apply fresh_name_is to _ Fr.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) ([(SaveL, consVal Hd Tl)]::EE)
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < IsEE: case IsEE.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < LenEE: apply length_exists_list_pair_string_value to IsEE1.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE N1
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < rename N1 to Len.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Acc': case Acc (keep).

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < NNS: assert newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE.

Subgoal 6.2.5:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE

 < unfold .

Subgoal 6.2.5:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 exists N SNames BNames,
   ((((length EE Len /\ drop N ([(SaveL, Tl)]::EE) EE) /\
   take N ([(SaveL, Tl)]::EE) [[(SaveL, Tl)]]) /\
   names [[(SaveL, Tl)]] SNames) /\
   names EE BNames) /\
   (forall X, mem X SNames -> mem X BNames -> false)

 < exists 1,
   [SaveL],
   Names.

Subgoal 6.2.5:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 ((((length EE Len /\ drop 1 ([(SaveL, Tl)]::EE) EE) /\
 take 1 ([(SaveL, Tl)]::EE) [[(SaveL, Tl)]]) /\
 names [[(SaveL, Tl)]] [SaveL]) /\
 names EE Names) /\
 (forall X, mem X [SaveL] -> mem X Names -> false)

 < split.

Subgoal 6.2.5.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 length EE Len

 < search.

Subgoal 6.2.5.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 drop 1 ([(SaveL, Tl)]::EE) EE

 < search.

Subgoal 6.2.5.3:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 take 1 ([(SaveL, Tl)]::EE) [[(SaveL, Tl)]]

 < search.

Subgoal 6.2.5.4:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 names [[(SaveL, Tl)]] [SaveL]

 < search.

Subgoal 6.2.5.5:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 names EE Names

 < search.

Subgoal 6.2.5.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
============================
 forall X, mem X [SaveL] -> mem X Names -> false

 < intros ML MN.

Subgoal 6.2.5.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
ML : mem X1 [SaveL]
MN : mem X1 Names
============================
 false

 < ML: case ML.

Subgoal 6.2.5.6.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
MN : mem SaveL Names
============================
 false

 < apply fresh_name_not_mem to Fr _.

Subgoal 6.2.5.6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
MN : mem X1 Names
ML : mem X1 []
============================
 false

 < case ML.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Ev: apply evalStmt_newNameScopes_exists_ES to _ _ _ _ IL2 NNS.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply ext_size_is_int_iterateList to IL.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < LN: apply lt_plus_one to Plus _.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < EvP: assert <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2.

Subgoal 6.2.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < apply ext_size_is_int_evalStmt to IL2.

Subgoal 6.2.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < apply ext_size_pos_evalStmt to IL2.

Subgoal 6.2.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < apply ext_size_pos_iterateList to IL3.

Subgoal 6.2.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
H9 : 0 <= N3
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < Or: apply lt_left to IL1 _ _.

Subgoal 6.2.6:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
H9 : 0 <= N3
Or : N2 < N \/ N2 = N
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < L: case Or.

Subgoal 6.2.6.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
H9 : 0 <= N3
L : N2 < N
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < L': apply less_integer_transitive to L LN.

Subgoal 6.2.6.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
H9 : 0 <= N3
L : N2 < N
L' : N2 < N'
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < A2: apply Acc' to _ L'.

Subgoal 6.2.6.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
H9 : 0 <= N3
L : N2 < N
L' : N2 < N'
A2 : acc N2 *
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < apply IH3 to Ev A2 _ _ _.

Subgoal 6.2.6.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
H7 : is_integer N2
H8 : 0 <= N2
H9 : 0 <= N3
L : N2 < N
L' : N2 < N'
A2 : acc N2 *
H10 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < search.

Subgoal 6.2.6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N
H6 : is_integer N
LN : N < N'
H7 : is_integer N
H8 : 0 <= N
H9 : 0 <= N3
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < A2: apply Acc' to _ LN.

Subgoal 6.2.6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N
H6 : is_integer N
LN : N < N'
H7 : is_integer N
H8 : 0 <= N
H9 : 0 <= N3
A2 : acc N *
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < apply IH3 to Ev A2 _ _ _.

Subgoal 6.2.6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N
H6 : is_integer N
LN : N < N'
H7 : is_integer N
H8 : 0 <= N
H9 : 0 <= N3
A2 : acc N *
H10 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
============================
 <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2

 < search.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Ev': apply drop_ext_size_evalStmt to Ev.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < EvB: apply drop_ext_size_evalStmt to IL2.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Eq: assert EE_A' = Scope::([(SaveL, Tl)]::EE3).

Subgoal 6.2.7:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < NNS+: apply evalStmt_newNameScopes to _ _ _ _ Ev' EvB NNS.

Subgoal 6.2.7:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len EE_A' (Scope::EE3)
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < NNS+: case NNS+.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < IsLen: apply length_is to LenEE.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
IsLen : is_integer Len
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < P: apply plus_integer_total to _ IsLen with
        N1 = 1.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames N4
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
IsLen : is_integer Len
P : 1 + Len = N4
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < LenEE+: assert length ([(X, Hd)]::EE) N4.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames N4
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
IsLen : is_integer Len
P : 1 + Len = N4
LenEE+ : length ([(X, Hd)]::EE) N4
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < LenEE3+: apply evalStmt_keep_scopes to _ _ _ EvB LenEE+.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames N4
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
IsLen : is_integer Len
P : 1 + Len = N4
LenEE+ : length ([(X, Hd)]::EE) N4
LenEE3+ : length (Scope::EE3) N4
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < apply length_unique to LenEE3+ NNS+.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
IsLen : is_integer Len
P : 1 + Len = Len
LenEE+ : length ([(X, Hd)]::EE) Len
LenEE3+ : length (Scope::EE3) Len
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < L: apply lt_plus_one to P _.

Subgoal 6.2.7.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A' N1 SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length (Scope::EE3) Len
NNS+1 : drop N1 EE_A' (Scope::EE3)
NNS+2 : take N1 EE_A' [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names (Scope::EE3) BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
IsLen : is_integer Len
P : 1 + Len = Len
LenEE+ : length ([(X, Hd)]::EE) Len
LenEE3+ : length (Scope::EE3) Len
L : Len < Len
============================
 EE_A' = Scope::([(SaveL, Tl)]::EE3)

 < apply less_integer_not_eq to L.

Subgoal 6.2.7.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len AR
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::AR) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::AR) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::AR) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR EE3
============================
 Scope::AR = Scope::([(SaveL, Tl)]::EE3)

 < NNS+: case NNS+.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len AR N1 SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::AR) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::AR) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::AR) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+1 : drop N1 AR EE3
NNS+2 : take N1 AR [[(SaveL, Tl)]]
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
============================
 Scope::AR = Scope::([(SaveL, Tl)]::EE3)

 < Take: case NNS+2.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1 SNames BNames N4 L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+1 : drop N1 ([(SaveL, Tl)]::L) EE3
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + N4 = N1
Take1 : take N4 L []
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < case Take1.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1 SNames BNames L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+1 : drop N1 ([(SaveL, Tl)]::L) EE3
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = N1
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < compute Take.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+1 : drop 1 ([(SaveL, Tl)]::L) EE3
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < Drop: case NNS+1.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L N5
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N5 = 1
Drop1 : drop N5 L EE3
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < apply drop_is_integer to Drop1.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L N5
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + N5 = 1
Drop1 : drop N5 L EE3
H7 : is_integer N5
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < apply plus_integer_unique_addend to _ _ _ Take Drop.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L EE3
H7 : is_integer 0
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < Eq: assert L = EE3.

Subgoal 6.2.7.2.1.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L EE3
H7 : is_integer 0
============================
 L = EE3

 < Drop': case Drop1.

Subgoal 6.2.7.2.1.1.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
============================
 EE3 = EE3

 < search.

Subgoal 6.2.7.2.1.1.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames N6 L1 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
Drop' : 1 + N6 = 0
Drop'1 : drop N6 L1 EE3
============================
 X1::L1 = EE3

 < GEq: apply drop_geq_0 to Drop'1.

Subgoal 6.2.7.2.1.1.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames N6 L1 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
Drop' : 1 + N6 = 0
Drop'1 : drop N6 L1 EE3
GEq : N6 >= 0
============================
 X1::L1 = EE3

 < P: assert 1 + -1 = 0.

Subgoal 6.2.7.2.1.1.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames N6 L1 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
Drop' : 1 + N6 = 0
Drop'1 : drop N6 L1 EE3
GEq : N6 >= 0
P : 1 + -1 = 0
============================
 X1::L1 = EE3

 < apply drop_is_integer to Drop'1.

Subgoal 6.2.7.2.1.1.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames N6 L1 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
Drop' : 1 + N6 = 0
Drop'1 : drop N6 L1 EE3
GEq : N6 >= 0
P : 1 + -1 = 0
H8 : is_integer N6
============================
 X1::L1 = EE3

 < apply plus_integer_unique_addend to _ _ _ P Drop'.

Subgoal 6.2.7.2.1.1.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L1 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
Drop' : 1 + -1 = 0
Drop'1 : drop -1 L1 EE3
GEq : -1 >= 0
P : 1 + -1 = 0
H8 : is_integer -1
============================
 X1::L1 = EE3

 < LEq: case GEq.

Subgoal 6.2.7.2.1.1.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L1 X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::(X1::L1))) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
H7 : is_integer 0
Drop' : 1 + -1 = 0
Drop'1 : drop -1 L1 EE3
P : 1 + -1 = 0
H8 : is_integer -1
LEq : 0 <= -1
============================
 X1::L1 = EE3

 < case LEq.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames L
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::L)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 L EE3
H7 : is_integer 0
Eq : L = EE3
============================
 Scope::([(SaveL, Tl)]::L) = Scope::([(SaveL, Tl)]::EE3)

 < case Eq.

Subgoal 6.2.7.2.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len SNames BNames
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
NNS+ : length EE3 Len
NNS+3 : names [[(SaveL, Tl)]] SNames
NNS+4 : names EE3 BNames
NNS+5 : forall X, mem X SNames -> mem X BNames -> false
Take : 1 + 0 = 1
Drop : 1 + 0 = 1
Drop1 : drop 0 EE3 EE3
H7 : is_integer 0
============================
 Scope::([(SaveL, Tl)]::EE3) = Scope::([(SaveL, Tl)]::EE3)

 < search.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < IsLen: apply length_is to LenEE.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < P: apply plus_integer_total to _ IsLen with
        N1 = 1.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < LenEE+: assert length ([(X, Hd)]::EE) N1.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < LenBR++: apply evalStmt_keep_scopes to _ _ _ EvB LenEE+.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR++ : length (Scope::(S::BR)) N1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < LenBR+: case LenBR++.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1 N'1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+ : length (S::BR) N'1
LenBR+1 : 1 + N'1 = N1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < apply length_is to LenBR+.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1 N'1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+ : length (S::BR) N'1
LenBR+1 : 1 + N'1 = N1
H7 : is_integer N'1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < LenBR: case LenBR+.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1 N'1 N'2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+1 : 1 + N'1 = N1
H7 : is_integer N'1
LenBR : length BR N'2
LenBR1 : 1 + N'2 = N'1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < apply length_is to LenBR.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1 N'1 N'2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+1 : 1 + N'1 = N1
H7 : is_integer N'1
LenBR : length BR N'2
LenBR1 : 1 + N'2 = N'1
H8 : is_integer N'2
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < LEq: apply newNameScopes_length to NNS+ LenBR.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd Len BR S AR1 N1 N'1 N'2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] Len AR1 BR
IsLen : is_integer Len
P : 1 + Len = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+1 : 1 + N'1 = N1
H7 : is_integer N'1
LenBR : length BR N'2
LenBR1 : 1 + N'2 = N'1
H8 : is_integer N'2
LEq : Len <= N'2
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < apply plus_integer_unique_addend to _ _ _ P LenBR+1.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd BR S AR1 N1 N'1 N'2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE N'1
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] N'1 ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] N'1 AR1 BR
IsLen : is_integer N'1
P : 1 + N'1 = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+1 : 1 + N'1 = N1
H7 : is_integer N'1
LenBR : length BR N'2
LenBR1 : 1 + N'2 = N'1
H8 : is_integer N'2
LEq : N'1 <= N'2
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < L: apply lt_plus_one to LenBR1 _.

Subgoal 6.2.7.2.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope O2 O3 Tl Hd BR S AR1 N1 N'1 N'2
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2 N2 **
IL3 : <iterateList {ES}> FE (S::BR) Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE N'1
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] N'1 ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::(S::AR1)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::(S::BR)) O2
NNS+ : newNameScopes [[(SaveL, Tl)]] N'1 AR1 BR
IsLen : is_integer N'1
P : 1 + N'1 = N1
LenEE+ : length ([(X, Hd)]::EE) N1
LenBR+1 : 1 + N'1 = N1
H7 : is_integer N'1
LenBR : length BR N'2
LenBR1 : 1 + N'2 = N'1
H8 : is_integer N'2
LEq : N'1 <= N'2
L : N'2 < N'1
============================
 Scope::(S::AR1) = Scope::([(SaveL, Tl)]::(S::BR))

 < apply less_lesseq_flip_false to L LEq.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len EE_A'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body EE_A' O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Eq : EE_A' = Scope::([(SaveL, Tl)]::EE3)
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < case Eq.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Is': apply evalStmt_isCtx to _ _ _ Ev'.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_list (is_pair is_string is_value)) (Scope::([(SaveL, Tl)]::EE3))
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Is': case Is'.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
Is'1 : is_list (is_list (is_pair is_string is_value)) ([(SaveL, Tl)]::EE3)
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < IsN3: apply ext_size_is_int_iterateList to IL3.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
Is'1 : is_list (is_list (is_pair is_string is_value)) ([(SaveL, Tl)]::EE3)
IsN3 : is_integer N3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply ext_size_pos_iterateList to IL3.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
Is'1 : is_list (is_list (is_pair is_string is_value)) ([(SaveL, Tl)]::EE3)
IsN3 : is_integer N3
H7 : 0 <= N3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < P: apply plus_integer_total to _ IsN3 with
        N1 = 1.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
Is'1 : is_list (is_list (is_pair is_string is_value)) ([(SaveL, Tl)]::EE3)
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply lesseq_integer__add_positive to _ _ P with
     Base = 0.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
Is'1 : is_list (is_list (is_pair is_string is_value)) ([(SaveL, Tl)]::EE3)
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply ext_size_pos_evalStmt to IL2.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
Is'1 : is_list (is_list (is_pair is_string is_value)) ([(SaveL, Tl)]::EE3)
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Is'': case Is'1.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < N: apply names_exists to Is''1.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1 N4
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE3
N : names EE3 N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply names_is to _ N.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1 N4
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE3
N : names EE3 N4
H10 : is_list is_string N4
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Fr': apply fresh_name_exists to _ _ with
          Base = "L" Names = X::N4.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 Scope EE3 O2 O3 Tl Hd Len N1 N4 F
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 N2 **
IL3 : <iterateList {ES}> FE EE3 Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope::([(SaveL, Tl)]::EE3)) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2
Is' : is_list (is_pair is_string is_value) Scope
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE3
N : names EE3 N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < NS: apply evalStmt_names_same to _ _ _ EvB.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply fresh_name_unique_mems to Fr' Fr _ _.

Subgoal 6.2.8:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
============================
 forall X1, mem X1 (X::Names) -> mem X1 (X::N4)

 < intros M.

Subgoal 6.2.8:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 (X::Names)
============================
 mem X1 (X::N4)

 < M: case M.

Subgoal 6.2.8.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
============================
 mem X (X::N4)

 < search.

Subgoal 6.2.8.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 Names
============================
 mem X1 (X::N4)

 < apply names_same_names to NS Names N M.

Subgoal 6.2.8.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 Names
H11 : mem X1 N4
============================
 mem X1 (X::N4)

 < search.

Subgoal 6.2.9:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
============================
 forall X1, mem X1 (X::N4) -> mem X1 (X::Names)

 < intros M.

Subgoal 6.2.9:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 (X::N4)
============================
 mem X1 (X::Names)

 < M: case M.

Subgoal 6.2.9.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
============================
 mem X (X::Names)

 < search.

Subgoal 6.2.9.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 N4
============================
 mem X1 (X::Names)

 < NS': apply names_same_symmetric to NS.

Subgoal 6.2.9.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 N4
NS' : names_same EE'' EE
============================
 mem X1 (X::Names)

 < apply names_same_names to NS' N Names M.

Subgoal 6.2.9.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 F Scope' EE'' X1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) F
NS : names_same EE EE''
M : mem X1 N4
NS' : names_same EE'' EE
H11 : mem X1 Names
============================
 mem X1 (X::Names)

 < search.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Or: apply lt_right to IL1 _ _ _.

Subgoal 6.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
Or : N3 < N \/ N3 = N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < L: case Or.

Subgoal 6.2.10:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < LEq: apply less_integer_step_lesseq to _ _ L P.

Subgoal 6.2.10:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N1 <= N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < Or: apply lesseq_integer_less_or_eq to LEq.

Subgoal 6.2.10:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N1 <= N
Or : N1 < N \/ N1 = N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < L': case Or.

Subgoal 6.2.10.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N1 <= N
L' : N1 < N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < L'': apply less_integer_transitive to L' LN.

Subgoal 6.2.10.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N1 <= N
L' : N1 < N
L'' : N1 < N'
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < A: apply Acc' to _ L''.

Subgoal 6.2.10.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N1 <= N
L' : N1 < N
L'' : N1 < N'
A : acc N1 *
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply IH_IL_W to _ _ _ _ _ IL3 P A N Fr'.

Subgoal 6.2.10.1:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N1 N4 Scope' EE'' V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N1 <= N
L' : N1 < N
L'' : N1 < N'
A : acc N1 *
H11 : <evalStmt {P}> FE ([(SaveL, Tl)]::EE'') (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < search.

Subgoal 6.2.10.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N
H8 : 0 <= N
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N <= N
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < A: apply Acc' to _ LN.

Subgoal 6.2.10.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N
H8 : 0 <= N
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N <= N
A : acc N *
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply IH_IL_W to _ _ _ _ _ IL3 P A N Fr'.

Subgoal 6.2.10.2:

Variables: FE SaveL EE X Body EE' O Names N N' N2 N3 O2 O3 Tl Hd Len N4 Scope' EE'' V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N3 = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N3 **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N3
H7 : 0 <= N3
P : 1 + N3 = N
H8 : 0 <= N
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
L : N3 < N
LEq : N <= N
A : acc N *
H11 : <evalStmt {P}> FE ([(SaveL, Tl)]::EE'') (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < search.

Subgoal 6.2.11:

Variables: FE SaveL EE X Body EE' O Names N N' N2 O2 O3 Tl Hd Len N1 N4 Scope' EE''
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N
H7 : 0 <= N
P : 1 + N = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < apply IH_IL_W to _ _ _ _ _ IL3 Plus Acc N Fr'.

Subgoal 6.2.11:

Variables: FE SaveL EE X Body EE' O Names N N' N2 O2 O3 Tl Hd Len N1 N4 Scope' EE'' V'
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE V X Body EE' O,
        <iterateList {ES}> FE EE V X Body EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
        is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W_A : forall FE SaveL V EE X Body EE' O Names N N',
              is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
              is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
              is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ->
              1 + N = N' -> acc N' * -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
              exists V',
                <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IH6 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH7 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH8 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH9 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH10 : forall N FE EE V X Body EE' O,
         <iterateList {ES}> FE EE V X Body EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> is_value V -> is_string X ->
         is_stmt Body -> <iterateList {P}> FE EE V X Body EE' O
IH_IL_W : forall FE SaveL V EE X Body EE' O Names N N',
            is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) ([(SaveL, V)]::EE) ->
            is_value V -> is_string X -> is_stmt Body -> <iterateList {ES}> FE EE V X Body EE' O N ** ->
            1 + N = N' -> acc N' @ -> names EE Names -> fresh_name "L" (X::Names) SaveL ->
            exists V',
              <evalStmt {P}> FE ([(SaveL, V)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsX : is_string X
IsBody : is_stmt Body
IL : <iterateList {ES}> FE EE (consVal Hd Tl) X Body EE' O N @@
Plus : 1 + N = N'
Acc : acc N' @
Names : names EE Names
Fr : fresh_name "L" (X::Names) SaveL
IL1 : N2 + N = N
IL2 : <evalStmt {ES}> FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2 N2 **
IL3 : <iterateList {ES}> FE EE'' Tl X Body EE' O3 N **
IL4 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : <evalExpr {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (not (null (name SaveL))) trueVal []
H4 : <evalStmt {P}> FE ([]::([(SaveL, consVal Hd Tl)]::EE)) (declare intTy X (head (name SaveL))) ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) []
NEq : X = SaveL -> false
H5 : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, consVal Hd Tl)]::EE)) (assign SaveL (tail (name SaveL))) ([(X, Hd)]::([(SaveL, Tl)]::EE)) []
IsSaveL : is_string SaveL
IsEE : is_list (is_pair is_string is_value) [(SaveL, consVal Hd Tl)]
IsEE1 : is_list (is_list (is_pair is_string is_value)) EE
LenEE : length EE Len
Acc' : forall M, 0 <= M -> M < N' -> acc M *
NNS : newNameScopes [[(SaveL, Tl)]] Len ([(SaveL, Tl)]::EE) EE
Ev : <evalStmt {ES}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2 N2
H6 : is_integer N
LN : N < N'
EvP : <evalStmt {P}> FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
Ev' : evalStmt FE ([(X, Hd)]::([(SaveL, Tl)]::EE)) Body (Scope'::([(SaveL, Tl)]::EE'')) O2
EvB : evalStmt FE ([(X, Hd)]::EE) Body (Scope'::EE'') O2
Is' : is_list (is_pair is_string is_value) Scope'
IsN3 : is_integer N
H7 : 0 <= N
P : 1 + N = N1
H8 : 0 <= N1
H9 : 0 <= N2
Is'' : is_list (is_pair is_string is_value) [(SaveL, Tl)]
Is''1 : is_list (is_list (is_pair is_string is_value)) EE''
N : names EE'' N4
H10 : is_list is_string N4
Fr' : fresh_name "L" (X::N4) SaveL
NS : names_same EE EE''
H11 : <evalStmt {P}> FE ([(SaveL, Tl)]::EE'') (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O3
============================
 exists V',
   <evalStmt {P}> FE ([(SaveL, consVal Hd Tl)]::EE) (while (not (null (name SaveL))) (seq (declare intTy X (head (name SaveL))) (seq (assign SaveL (tail (name SaveL))) Body))) ([(SaveL, V')]::EE') O

 < search.

Proof completed.

 < Prove matchEval:host:paramName_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_paramName_forward.

Proof completed.

 < Prove_Constraint matchEval:host:proj_paramName_back.

Proof completed.

 < Prove matchEval:host:getFunEvalInfo_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_getFunEvalInfo_forward.

Proof completed.

 < Prove_Constraint matchEval:host:proj_getFunEvalInfo_back.

Proof completed.

 < Prove matchEval:host:evalProgram_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalProgram_forward.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalProgram_back.

Proof completed.

 < Theorem updateListIndex_typePres :
     forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out ->
       valueType Out (listTy Ty).

============================
 forall L Ty I V Out,
   valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out -> valueType Out (listTy Ty)

 < induction on 3.

IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
============================
 forall L Ty I V Out,
   valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out @ -> valueType Out (listTy Ty)

 < intros VTL VTV ULI.

Variables: L Ty I V Out
IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
VTL : valueType L (listTy Ty)
VTV : valueType V Ty
ULI : updateListIndex L I V Out @
============================
 valueType Out (listTy Ty)

 < ULI: case ULI.

Subgoal 1:

Variables: Ty V Tl VOld
IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
VTL : valueType (consVal VOld Tl) (listTy Ty)
VTV : valueType V Ty
============================
 valueType (consVal V Tl) (listTy Ty)

 < VTL: case VTL.

Subgoal 1:

Variables: Ty V Tl VOld
IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
VTV : valueType V Ty
VTL : valueType VOld Ty
VTL1 : valueType Tl (listTy Ty)
============================
 valueType (consVal V Tl) (listTy Ty)

 < search.

Subgoal 2:

Variables: Ty I V I1 TlNew X Tl
IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
VTL : valueType (consVal X Tl) (listTy Ty)
VTV : valueType V Ty
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
============================
 valueType (consVal X TlNew) (listTy Ty)

 < VTL: case VTL.

Subgoal 2:

Variables: Ty I V I1 TlNew X Tl
IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
VTV : valueType V Ty
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
VTL : valueType X Ty
VTL1 : valueType Tl (listTy Ty)
============================
 valueType (consVal X TlNew) (listTy Ty)

 < apply IH to _ _ ULI1.

Subgoal 2:

Variables: Ty I V I1 TlNew X Tl
IH : forall L Ty I V Out,
       valueType L (listTy Ty) -> valueType V Ty -> updateListIndex L I V Out * ->
       valueType Out (listTy Ty)
VTV : valueType V Ty
ULI : I - 1 = I1
ULI1 : updateListIndex Tl I1 V TlNew *
VTL : valueType X Ty
VTL1 : valueType Tl (listTy Ty)
H1 : valueType TlNew (listTy Ty)
============================
 valueType (consVal X TlNew) (listTy Ty)

 < search.

Proof completed.

 < Prove matchEval:host:matchRec_typePres.

Subgoal 2:

Variables: FTys
IH : forall V Fs FTys,
       is_value V -> matchRec V Fs * -> valueType V (recTy FTys) -> valFieldTys Fs FTys
IsV : is_value nilVal
MR : matchRec nilVal [("null", trueVal)] @
VTy : valueType nilVal (recTy FTys)
============================
 valFieldTys [("null", trueVal)] FTys

 < case VTy.

Subgoal 3:

Variables: FTys V2 V1
IH : forall V Fs FTys,
       is_value V -> matchRec V Fs * -> valueType V (recTy FTys) -> valFieldTys Fs FTys
IsV : is_value (consVal V1 V2)
MR : matchRec (consVal V1 V2) [("null", falseVal), ("head", V1), ("tail", V2)] @
VTy : valueType (consVal V1 V2) (recTy FTys)
============================
 valFieldTys [("null", falseVal), ("head", V1), ("tail", V2)] FTys

 < case VTy.

Proof completed.

 < Prove matchEval:host:evalExpr_typePres,
         matchEval:host:evalStmt_typePres,
         matchEval:host:evalArgs_typePres,
         matchEval:host:evalRecFields_typePres
   with
      iterateList_typePres : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         IsET : is_list (is_list (is_pair is_string is_typ)) ET ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsEE : is_list (is_list (is_pair is_string is_value)) EE ->
         Ty : stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
         VTy : valueType V (listTy Ty) ->
         IsTy : is_typ Ty ->
         IL : iterateList FE EE V X Body EE' O ->
         Funs : (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, RVVal, ArgNames, Body) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') ->
         Ctxs : related_all_scopes ET EE ->
         related_all_scopes ET' EE'
      on IL as IH_IL.

Subgoal 1.32:

Variables: FT ET Ty FE EE Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (nil Ty1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (nil Ty1) Ty
Ev : evalExpr FE EE (nil Ty1) nilVal [] @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
============================
 valueType nilVal Ty

 < case Ty.

Subgoal 1.32:

Variables: FT ET FE EE Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (nil Ty1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (nil Ty1) nilVal [] @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
============================
 valueType nilVal (listTy Ty1)

 < search.

Subgoal 1.33:

Variables: FT ET Ty FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (cons E1 E2)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (cons E1 E2) Ty
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
============================
 valueType (consVal V1 V2) Ty

 < case IsE.

Subgoal 1.33:

Variables: FT ET Ty FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (cons E1 E2) Ty
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 valueType (consVal V1 V2) Ty

 < Ty: case Ty.

Subgoal 1.33:

Variables: FT ET FE EE O O2 O3 V2 V1 E2 E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Ty : typeOf FT ET E1 Ty1
Ty1 : typeOf FT ET E2 (listTy Ty1)
============================
 valueType (consVal V1 V2) (listTy Ty1)

 < apply IH_E to _ _ _ _ _ _ Ev1 _ _.

Subgoal 1.33:

Variables: FT ET FE EE O O2 O3 V2 V1 E2 E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Ty : typeOf FT ET E1 Ty1
Ty1 : typeOf FT ET E2 (listTy Ty1)
H3 : valueType V1 Ty1
============================
 valueType (consVal V1 V2) (listTy Ty1)

 < apply IH_E to _ _ _ _ _ _ Ev2 _ _.

Subgoal 1.33:

Variables: FT ET FE EE O O2 O3 V2 V1 E2 E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Ty : typeOf FT ET E1 Ty1
Ty1 : typeOf FT ET E2 (listTy Ty1)
H3 : valueType V1 Ty1
H4 : valueType V2 (listTy Ty1)
============================
 valueType (consVal V1 V2) (listTy Ty1)

 < search.

Subgoal 1.34:

Variables: FT ET Ty FE EE O V Tl E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (head E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (head E1) Ty
Ev : evalExpr FE EE (head E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
============================
 valueType V Ty

 < case IsE.

Subgoal 1.34:

Variables: FT ET Ty FE EE O V Tl E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (head E1) Ty
Ev : evalExpr FE EE (head E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
============================
 valueType V Ty

 < Ty: case Ty.

Subgoal 1.34:

Variables: FT ET Ty FE EE O V Tl E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
Ty : typeOf FT ET E1 (listTy Ty)
============================
 valueType V Ty

 < VT: apply IH_E to _ _ _ _ _ _ Ev1 _ _.

Subgoal 1.34:

Variables: FT ET Ty FE EE O V Tl E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
Ty : typeOf FT ET E1 (listTy Ty)
VT : valueType (consVal V Tl) (listTy Ty)
============================
 valueType V Ty

 < VT: case VT.

Subgoal 1.34:

Variables: FT ET Ty FE EE O V Tl E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
Ty : typeOf FT ET E1 (listTy Ty)
VT : valueType V Ty
VT1 : valueType Tl (listTy Ty)
============================
 valueType V Ty

 < search.

Subgoal 1.35:

Variables: FT ET Ty FE EE O V Hd E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (tail E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (tail E1) Ty
Ev : evalExpr FE EE (tail E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
============================
 valueType V Ty

 < case IsE.

Subgoal 1.35:

Variables: FT ET Ty FE EE O V Hd E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (tail E1) Ty
Ev : evalExpr FE EE (tail E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
============================
 valueType V Ty

 < Ty: case Ty.

Subgoal 1.35:

Variables: FT ET FE EE O V Hd E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
Ty : typeOf FT ET E1 (listTy Ty1)
============================
 valueType V (listTy Ty1)

 < VT: apply IH_E to _ _ _ _ _ _ Ev1 _ _.

Subgoal 1.35:

Variables: FT ET FE EE O V Hd E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
Ty : typeOf FT ET E1 (listTy Ty1)
VT : valueType (consVal Hd V) (listTy Ty1)
============================
 valueType V (listTy Ty1)

 < VT: case VT.

Subgoal 1.35:

Variables: FT ET FE EE O V Hd E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
Ty : typeOf FT ET E1 (listTy Ty1)
VT : valueType Hd Ty1
VT1 : valueType V (listTy Ty1)
============================
 valueType V (listTy Ty1)

 < search.

Subgoal 1.36:

Variables: FT ET Ty FE EE O E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (null E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (null E1) Ty
Ev : evalExpr FE EE (null E1) trueVal O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 nilVal O *
============================
 valueType trueVal Ty

 < case Ty.

Subgoal 1.36:

Variables: FT ET FE EE O E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (null E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 nilVal O *
H1 : typeOf FT ET E1 (listTy Ty1)
============================
 valueType trueVal boolTy

 < search.

Subgoal 1.37:

Variables: FT ET Ty FE EE O Hd Tl E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (null E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (null E1) Ty
Ev : evalExpr FE EE (null E1) falseVal O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
============================
 valueType falseVal Ty

 < case Ty.

Subgoal 1.37:

Variables: FT ET FE EE O Hd Tl E1 Ty1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsE : is_expr (null E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
H1 : typeOf FT ET E1 (listTy Ty1)
============================
 valueType falseVal boolTy

 < search.

Subgoal 2.15:

Variables: FT ET ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsS : is_stmt (listUpdate L I E)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ET (listUpdate L I E) ET'
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
============================
 related_all_scopes ET' EE'

 < case IsS.

Subgoal 2.15:

Variables: FT ET ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ET (listUpdate L I E) ET'
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 related_all_scopes ET' EE'

 < Ty: case Ty.

Subgoal 2.15:

Variables: FT ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L Ty
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
Ty : lookupScopes L ET' (listTy Ty)
Ty1 : typeOf FT ET' I intTy
Ty2 : typeOf FT ET' E Ty
============================
 related_all_scopes ET' EE'

 < VT: apply IH_E to _ _ _ _ _ _ Ev4 _ _.

Subgoal 2.15:

Variables: FT ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L Ty
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
Ty : lookupScopes L ET' (listTy Ty)
Ty1 : typeOf FT ET' I intTy
Ty2 : typeOf FT ET' E Ty
VT : valueType V Ty
============================
 related_all_scopes ET' EE'

 < VTL: apply related_all_scopes_lookupScopes to Ctxs Ty Ev1.

Subgoal 2.15:

Variables: FT ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L Ty
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
Ty : lookupScopes L ET' (listTy Ty)
Ty1 : typeOf FT ET' I intTy
Ty2 : typeOf FT ET' E Ty
VT : valueType V Ty
VTL : valueType LV (listTy Ty)
============================
 related_all_scopes ET' EE'

 < apply updateListIndex_typePres to VTL VT Ev5.

Subgoal 2.15:

Variables: FT ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L Ty
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
Ty : lookupScopes L ET' (listTy Ty)
Ty1 : typeOf FT ET' I intTy
Ty2 : typeOf FT ET' E Ty
VT : valueType V Ty
VTL : valueType LV (listTy Ty)
H4 : valueType LV2 (listTy Ty)
============================
 related_all_scopes ET' EE'

 < apply related_all_scopes_replaceScopes to _ _ _ Ev6 _ _.

Subgoal 2.15:

Variables: FT ET' FE EE EE' O LV VI O2 N V O3 LV2 E I L Ty
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
Ty : lookupScopes L ET' (listTy Ty)
Ty1 : typeOf FT ET' I intTy
Ty2 : typeOf FT ET' E Ty
VT : valueType V Ty
VTL : valueType LV (listTy Ty)
H4 : valueType LV2 (listTy Ty)
H5 : related_all_scopes ET' EE'
============================
 related_all_scopes ET' EE'

 < search.

Subgoal 2.16:

Variables: FT ET ET' FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsS : is_stmt (listForeach X L Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ET (listForeach X L Body) ET'
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 related_all_scopes ET' EE'

 < case IsS.

Subgoal 2.16:

Variables: FT ET ET' FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ET (listForeach X L Body) ET'
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 related_all_scopes ET' EE'

 < Ty: case Ty.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty TC1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body TC1
============================
 related_all_scopes ET' EE'

 < IsLTy: apply typeOf_isTy to _ _ _ Ty.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty TC1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body TC1
IsLTy : is_typ (listTy Ty)
============================
 related_all_scopes ET' EE'

 < case IsLTy.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty TC1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body TC1
H4 : is_typ Ty
============================
 related_all_scopes ET' EE'

 < apply stmtOK_older_scopes_same to _ _ _ Ty1.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body (Scope'::ET')
H4 : is_typ Ty
============================
 related_all_scopes ET' EE'

 < apply evalExpr_isValue to _ _ _ Ev1.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body (Scope'::ET')
H4 : is_typ Ty
H5 : is_value LV
============================
 related_all_scopes ET' EE'

 < apply IH_E to _ _ _ _ _ _ Ev1 _ _.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body (Scope'::ET')
H4 : is_typ Ty
H5 : is_value LV
H6 : valueType LV (listTy Ty)
============================
 related_all_scopes ET' EE'

 < apply IH_IL to _ _ _ _ _ _ _ Ty1 _ _ Ev2 _ _.

Subgoal 2.16:

Variables: FT ET' FE EE EE' O LV O2 O3 Body L X Ty Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET'
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET' EE
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
Ty : typeOf FT ET' L (listTy Ty)
Ty1 : stmtOK FT ([(X, Ty)]::ET') Body (Scope'::ET')
H4 : is_typ Ty
H5 : is_value LV
H6 : valueType LV (listTy Ty)
H7 : related_all_scopes ET' EE'
============================
 related_all_scopes ET' EE'

 < search.

Subgoal 5.1:

Variables: X Body FT ET Ty Sc ET' FE EE'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET')
VTy : valueType nilVal (listTy Ty)
IsTy : is_typ Ty
IL : iterateList FE EE' nilVal X Body EE' [] @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE'
============================
 related_all_scopes ET' EE'

 < apply stmtOK_older_scopes_same to _ _ _ Ty.

Subgoal 5.1:

Variables: X Body FT ET Ty FE EE' Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
VTy : valueType nilVal (listTy Ty)
IsTy : is_typ Ty
IL : iterateList FE EE' nilVal X Body EE' [] @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE'
============================
 related_all_scopes ET EE'

 < search.

Subgoal 5.2:

Variables: X Body FT ET Ty Sc ET' FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET')
VTy : valueType (consVal Hd Tl) (listTy Ty)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 related_all_scopes ET' EE'

 < apply stmtOK_older_scopes_same to _ _ _ Ty.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
VTy : valueType (consVal Hd Tl) (listTy Ty)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 related_all_scopes ET EE'

 < case IsV.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
VTy : valueType (consVal Hd Tl) (listTy Ty)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 related_all_scopes ET EE'

 < case VTy.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
============================
 related_all_scopes ET EE'

 < assert related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE).

Subgoal 5.2.1:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
============================
 related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)

 < unfold .

Subgoal 5.2.1.1:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
============================
 forall X1 T,
   lookup [(X, Ty)] X1 T -> exists V, lookup [(X, Hd)] X1 V /\ valueType V T

 < intros L.

Subgoal 5.2.1.1:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope' X1 T
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
L : lookup [(X, Ty)] X1 T
============================
 exists V, lookup [(X, Hd)] X1 V /\ valueType V T

 < L: case L.

Subgoal 5.2.1.1.1:

Variables: Body FT ET FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope' X1 T
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X1
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X1, T)]::ET) Body (Scope'::ET)
IsTy : is_typ T
IL : iterateList FE EE (consVal Hd Tl) X1 Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X1, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X1 Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd T
H4 : valueType Tl (listTy T)
============================
 exists V, lookup [(X1, Hd)] X1 V /\ valueType V T

 < search.

Subgoal 5.2.1.1.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope' X1 T
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
L : X = X1 -> false
L1 : lookup [] X1 T
============================
 exists V, lookup [(X, Hd)] X1 V /\ valueType V T

 < case L1.

Subgoal 5.2.1.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
============================
 forall X1, no_lookup [(X, Ty)] X1 -> no_lookup [(X, Hd)] X1

 < intros NL.

Subgoal 5.2.1.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope' X1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
NL : no_lookup [(X, Ty)] X1
============================
 no_lookup [(X, Hd)] X1

 < case NL.

Subgoal 5.2.1.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope' X1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : X = X1 -> false
H6 : no_lookup [] X1
============================
 no_lookup [(X, Hd)] X1

 < search.

Subgoal 5.2.1.3:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
============================
 related_all_scopes ET EE

 < search.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)
============================
 related_all_scopes ET EE'

 < Ctxs': apply IH_S to _ _ _ _ _ Ty IL1 _ _.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)
Ctxs' : related_all_scopes (Scope'::ET) (Scope::EE3)
============================
 related_all_scopes ET EE'

 < case Ctxs'.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)
H6 : forall X T,
       lookup Scope' X T -> exists V, lookup Scope X V /\ valueType V T
H7 : forall X, no_lookup Scope' X -> no_lookup Scope X
H8 : related_all_scopes ET EE3
============================
 related_all_scopes ET EE'

 < IsEE3+: apply evalStmt_isCtx to _ _ _ IL1.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)
H6 : forall X T,
       lookup Scope' X T -> exists V, lookup Scope X V /\ valueType V T
H7 : forall X, no_lookup Scope' X -> no_lookup Scope X
H8 : related_all_scopes ET EE3
IsEE3+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 related_all_scopes ET EE'

 < case IsEE3+.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)
H6 : forall X T,
       lookup Scope' X T -> exists V, lookup Scope X V /\ valueType V T
H7 : forall X, no_lookup Scope' X -> no_lookup Scope X
H8 : related_all_scopes ET EE3
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 related_all_scopes ET EE'

 < apply IH_IL to _ _ _ _ _ _ _ Ty _ _ IL2 _ _.

Subgoal 5.2:

Variables: X Body FT ET Ty FE EE EE' O Scope EE3 O2 O3 Tl Hd Scope'
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IH_IL : forall V X Body FT ET Ty Sc ET' FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ([(X, Ty)]::ET) Body (Sc::ET') ->
          valueType V (listTy Ty) -> is_typ Ty -> iterateList FE EE V X Body EE' O * ->
          (forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv') -> related_all_scopes ET EE ->
          related_all_scopes ET' EE'
IsX : is_string X
IsBody : is_stmt Body
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : stmtOK FT ([(X, Ty)]::ET) Body (Scope'::ET)
IsTy : is_typ Ty
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
Funs : forall F RetTy ArgTys ArgNames Body1 RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body1))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body1 TyEnv'
Ctxs : related_all_scopes ET EE
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : valueType Hd Ty
H4 : valueType Tl (listTy Ty)
H5 : related_all_scopes ([(X, Ty)]::ET) ([(X, Hd)]::EE)
H6 : forall X T,
       lookup Scope' X T -> exists V, lookup Scope X V /\ valueType V T
H7 : forall X, no_lookup Scope' X -> no_lookup Scope X
H8 : related_all_scopes ET EE3
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE3
H11 : related_all_scopes ET EE'
============================
 related_all_scopes ET EE'

 < search.

Proof completed.

 < Prove matchEval:host:paramTy_paramName_same.

Proof completed.

 < Prove matchEval:host:funOK_getFunEvalInfo_related.

Proof completed.

 < Prove matchEval:host:evalExpr_output_forms,
         matchEval:host:evalStmt_output_forms,
         matchEval:host:evalArgs_output_forms,
         matchEval:host:evalRecFields_output_forms
   with
      iterateList_output_forms : forall V X Body FE EE EE' O,
         IsV : is_value V ->
         IsX : is_string X ->
         IsBody : is_stmt Body ->
         IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         IsEE : is_list (is_list (is_pair is_string is_value)) EE ->
         IL : iterateList FE EE V X Body EE' O ->
         output_forms O
      on IL as IH_IL.

Subgoal 1.32:

Variables: FE EE Ty
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsE : is_expr (nil Ty)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (nil Ty) nilVal [] @
============================
 output_forms []

 < search.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsE : is_expr (cons E1 E2)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
============================
 output_forms O

 < case IsE.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : output_forms O2
============================
 output_forms O

 < apply IH_E to _ _ _ Ev2.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : output_forms O2
H4 : output_forms O3
============================
 output_forms O

 < apply output_forms_append to _ _ Ev3.

Subgoal 1.33:

Variables: FE EE O O2 O3 V2 V1 E2 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (cons E1 E2) (consVal V1 V2) O @
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
H3 : output_forms O2
H4 : output_forms O3
H5 : output_forms O
============================
 output_forms O

 < search.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsE : is_expr (head E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
============================
 output_forms O

 < case IsE.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.34:

Variables: FE EE V O Tl E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (head E1) V O @
Ev1 : evalExpr FE EE E1 (consVal V Tl) O *
H1 : is_expr E1
H2 : output_forms O
============================
 output_forms O

 < search.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsE : is_expr (tail E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
============================
 output_forms O

 < case IsE.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.35:

Variables: FE EE V O Hd E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (tail E1) V O @
Ev1 : evalExpr FE EE E1 (consVal Hd V) O *
H1 : is_expr E1
H2 : output_forms O
============================
 output_forms O

 < search.

Subgoal 1.36:

Variables: FE EE O E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
============================
 output_forms O

 < case IsE.

Subgoal 1.36:

Variables: FE EE O E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
H1 : is_expr E1
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.36:

Variables: FE EE O E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) trueVal O @
Ev1 : evalExpr FE EE E1 nilVal O *
H1 : is_expr E1
H2 : output_forms O
============================
 output_forms O

 < search.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsE : is_expr (null E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
============================
 output_forms O

 < case IsE.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
H1 : is_expr E1
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.37:

Variables: FE EE O Hd Tl E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (null E1) falseVal O @
Ev1 : evalExpr FE EE E1 (consVal Hd Tl) O *
H1 : is_expr E1
H2 : output_forms O
============================
 output_forms O

 < search.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsS : is_stmt (listUpdate L I E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
============================
 output_forms O

 < case IsS.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
============================
 output_forms O

 < apply IH_E to _ _ _ Ev2.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : output_forms O2
============================
 output_forms O

 < apply IH_E to _ _ _ Ev4.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : output_forms O2
H5 : output_forms O3
============================
 output_forms O

 < apply output_forms_append to _ _ Ev7.

Subgoal 2.15:

Variables: FE EE EE' O LV VI O2 N V O3 LV2 E I L
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listUpdate L I E) EE' O @
Ev1 : lookupScopes L EE LV
Ev2 : evalExpr FE EE I VI O2 *
Ev3 : matchInt VI N
Ev4 : evalExpr FE EE E V O3 *
Ev5 : updateListIndex LV N V LV2
Ev6 : replaceScopes L LV2 EE EE'
Ev7 : O2 ++ O3 = O
H1 : is_string L
H2 : is_expr I
H3 : is_expr E
H4 : output_forms O2
H5 : output_forms O3
H6 : output_forms O
============================
 output_forms O

 < search.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsS : is_stmt (listForeach X L Body)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 output_forms O

 < case IsS.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : output_forms O2
============================
 output_forms O

 < apply evalExpr_isValue to _ _ _ Ev1.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : output_forms O2
H5 : is_value LV
============================
 output_forms O

 < apply IH_IL to _ _ _ _ _ Ev2.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : output_forms O2
H5 : is_value LV
H6 : output_forms O3
============================
 output_forms O

 < apply output_forms_append to _ _ Ev3.

Subgoal 2.16:

Variables: FE EE EE' O LV O2 O3 Body L X
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (listForeach X L Body) EE' O @
Ev1 : evalExpr FE EE L LV O2 *
Ev2 : iterateList FE EE LV X Body EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string X
H2 : is_expr L
H3 : is_stmt Body
H4 : output_forms O2
H5 : is_value LV
H6 : output_forms O3
H7 : output_forms O
============================
 output_forms O

 < search.

Subgoal 5.1:

Variables: X Body FE EE'
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsV : is_value nilVal
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE'
IL : iterateList FE EE' nilVal X Body EE' [] @
============================
 output_forms []

 < search.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsV : is_value (consVal Hd Tl)
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
============================
 output_forms O

 < case IsV.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
============================
 output_forms O

 < apply IH_S to _ _ _ IL1.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : output_forms O2
============================
 output_forms O

 < IsEE3+: apply evalStmt_isCtx to _ _ _ IL1.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : output_forms O2
IsEE3+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE3)
============================
 output_forms O

 < case IsEE3+.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : output_forms O2
H4 : is_list (is_pair is_string is_value) Scope
H5 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 output_forms O

 < apply IH_IL to _ _ _ _ _ IL2.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : output_forms O2
H4 : is_list (is_pair is_string is_value) Scope
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : output_forms O3
============================
 output_forms O

 < apply output_forms_append to _ _ IL3.

Subgoal 5.2:

Variables: X Body FE EE EE' O Scope EE3 O2 O3 Tl Hd
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IH_IL : forall V X Body FE EE EE' O,
          is_value V -> is_string X -> is_stmt Body -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> iterateList FE EE V X Body EE' O * ->
          output_forms O
IsX : is_string X
IsBody : is_stmt Body
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IL : iterateList FE EE (consVal Hd Tl) X Body EE' O @
IL1 : evalStmt FE ([(X, Hd)]::EE) Body (Scope::EE3) O2 *
IL2 : iterateList FE EE3 Tl X Body EE' O3 *
IL3 : O2 ++ O3 = O
H1 : is_value Hd
H2 : is_value Tl
H3 : output_forms O2
H4 : is_list (is_pair is_string is_value) Scope
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : output_forms O3
H7 : output_forms O
============================
 output_forms O

 < search.

Proof completed.

 < Prove matchEval:host:evalProgram_output_forms.

Proof completed.

 < Prove matchEval:host:paramName_exists.

Proof completed.

 < Prove matchEval:host:getFunEvalInfo_exists.

Proof completed.

Back to example home