/export/starexec/sandbox2/solver/bin/starexec_run_c /export/starexec/sandbox2/benchmark/theBenchmark.c /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


MAYBE
proof of /export/starexec/sandbox2/benchmark/theBenchmark.c
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


Termination of the given C Problem could not be shown:

(0) C Problem
(1) CToIRSProof [EQUIVALENT, 0 ms]
(2) IntTRS
    (3) IRS2T2 [EQUIVALENT, 0 ms]
    (4) T2IntSys
        (5) T2 Underapproximation [COMPLETE, 1173 ms]
        (6) T2IntSys
        (7) T2 Underapproximation [COMPLETE, 922 ms]
        (8) T2IntSys
    (9) TerminationGraphProcessor [SOUND, 50 ms]
    (10) IntTRS
        (11) IntTRSCompressionProof [EQUIVALENT, 33 ms]
        (12) IntTRS
        (13) IntTRSNonPeriodicNontermProof [COMPLETE, 11 ms]
        (14) NO
(15) CToLLVMProof [EQUIVALENT, 174 ms]
(16) LLVM problem
    (17) LLVMToTerminationGraphProof [EQUIVALENT, 625 ms]
    (18) LLVM Symbolic Execution Graph
    (19) SymbolicExecutionGraphToLassoProof [EQUIVALENT, 0 ms]
    (20) AND
        (21) LLVM Symbolic Execution Lasso
            (22) Lasso2IRS [EQUIVALENT, 28 ms]
            (23) IntTRS
            (24) IRS2T2 [EQUIVALENT, 0 ms]
            (25) T2IntSys
            (26) T2 Underapproximation [COMPLETE, 902 ms]
            (27) T2IntSys
            (28) T2 Underapproximation [COMPLETE, 933 ms]
            (29) T2IntSys
        (30) LLVM Symbolic Execution Lasso
            (31) Lasso2IRS [EQUIVALENT, 12 ms]
            (32) IntTRS
            (33) IRS2T2 [EQUIVALENT, 0 ms]
            (34) T2IntSys
            (35) T2 Underapproximation [COMPLETE, 892 ms]
            (36) T2IntSys
    (37) SymbolicExecutionGraphToSCCProof [SOUND, 0 ms]
    (38) AND
        (39) LLVM Symbolic Execution SCC
            (40) SCC2IRS [SOUND, 11 ms]
            (41) IntTRS
            (42) IRS2T2 [EQUIVALENT, 0 ms]
            (43) T2IntSys
                (44) T2 Underapproximation [COMPLETE, 2 ms]
                (45) T2IntSys
                (46) T2 Underapproximation [COMPLETE, 1093 ms]
                (47) T2IntSys
            (48) IntTRSCompressionProof [EQUIVALENT, 0 ms]
            (49) IntTRS
                (50) TerminationGraphProcessor [EQUIVALENT, 8 ms]
                (51) IntTRS
                (52) IntTRSCompressionProof [EQUIVALENT, 0 ms]
                (53) IntTRS
        (54) LLVM Symbolic Execution SCC
            (55) SCC2IRS [SOUND, 1 ms]
            (56) IntTRS
                (57) IntTRSNonPeriodicNontermProof [COMPLETE, 0 ms]
                (58) NO
            (59) SCC2IRS [SOUND, 0 ms]
            (60) IntTRS
                (61) IntTRSCompressionProof [EQUIVALENT, 0 ms]
                (62) IntTRS
                (63) IntTRSNonPeriodicNontermProof [COMPLETE, 5 ms]
                (64) NO
    (65) SEGraph to IRS [EQUIVALENT, 33 ms]
    (66) IntTRS
        (67) IRS2T2 [EQUIVALENT, 0 ms]
        (68) T2IntSys
        (69) T2 Underapproximation [COMPLETE, 5013 ms]
        (70) T2IntSys
        (71) T2 Underapproximation [COMPLETE, 5103 ms]
        (72) T2IntSys


----------------------------------------

(0)
Obligation:
c file /export/starexec/sandbox2/benchmark/theBenchmark.c
----------------------------------------

(1) CToIRSProof (EQUIVALENT)
Parsed C Integer Program as IRS.
----------------------------------------

(2)
Obligation:
Rules:
f1(i) -> f2(x_1) :|: TRUE
f4(x) -> f7(arith) :|: TRUE && arith = x - 1
f5(x9) -> f8(x10) :|: TRUE && x10 = x9 + 1
f3(x2) -> f4(x2) :|: x2 < 0
f3(x3) -> f5(x3) :|: x3 >= 0
f7(x4) -> f6(x4) :|: TRUE
f8(x5) -> f6(x5) :|: TRUE
f2(x6) -> f3(x6) :|: x6 * x6 > 9
f6(x7) -> f2(x7) :|: TRUE
f2(x8) -> f9(x8) :|: x8 * x8 <= 9
Start term: f1(i)

----------------------------------------

(3) IRS2T2 (EQUIVALENT)
Transformed input IRS into an integer transition system.Used the following mapping from defined symbols to location IDs:

   (f1_1,1)
   (f2_1,2)
   (f4_1,3)
   (f7_1,4)
   (f5_1,5)
   (f8_1,6)
   (f3_1,7)
   (f6_1,8)
   (f9_1,9)

----------------------------------------

(4)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := nondet();
assume(0 = 0);
x0 := oldX1;
TO: 2;

FROM: 3;
oldX0 := x0;
oldX1 := -(1 - oldX0);
assume(0 = 0 && oldX1 = oldX0 - 1);
x0 := -(1 - oldX0);
TO: 4;

FROM: 5;
oldX0 := x0;
oldX1 := -(-(oldX0 + 1));
assume(0 = 0 && oldX1 = oldX0 + 1);
x0 := -(-(oldX0 + 1));
TO: 6;

FROM: 7;
oldX0 := x0;
assume(oldX0 < 0);
x0 := oldX0;
TO: 3;

FROM: 7;
oldX0 := x0;
assume(oldX0 >= 0);
x0 := oldX0;
TO: 5;

FROM: 4;
oldX0 := x0;
assume(0 = 0);
x0 := oldX0;
TO: 8;

FROM: 6;
oldX0 := x0;
assume(0 = 0);
x0 := oldX0;
TO: 8;

FROM: 2;
oldX0 := x0;
assume(oldX0 * oldX0 > 9);
x0 := oldX0;
TO: 7;

FROM: 8;
oldX0 := x0;
assume(0 = 0);
x0 := oldX0;
TO: 2;

FROM: 2;
oldX0 := x0;
assume(oldX0 * oldX0 <= 9);
x0 := oldX0;
TO: 9;


----------------------------------------

(5) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 5:
assume(x0 >= 0);



----------------------------------------

(6)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := nondet();
assume(0 = 0);
x0 := oldX1;
TO: 2;

FROM: 3;
oldX0 := x0;
oldX1 := -1 - -(x0);
assume(0 = 0 && -1 - -(x0) = x0 - 1);
x0 := -1 - -(x0);
TO: 4;

FROM: 5;
oldX0 := x0;
oldX1 := x0 + 1;
assume(0 = 0 && x0 + 1 = x0 + 1);
assume(x0 >= 0);
x0 := x0 + 1;
TO: 6;

FROM: 7;
oldX0 := x0;
assume(x0 < 0);
x0 := x0;
TO: 3;

FROM: 7;
oldX0 := x0;
assume(x0 >= 0);
x0 := x0;
TO: 5;

FROM: 4;
oldX0 := x0;
assume(0 = 0);
x0 := x0;
TO: 8;

FROM: 6;
oldX0 := x0;
assume(0 = 0);
x0 := x0;
TO: 8;

FROM: 2;
oldX0 := x0;
assume(x0 * x0 > 9);
x0 := x0;
TO: 7;

FROM: 8;
oldX0 := x0;
assume(0 = 0);
x0 := x0;
TO: 2;

FROM: 2;
oldX0 := x0;
assume(x0 * x0 <= 9);
x0 := x0;
TO: 9;


----------------------------------------

(7) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 3:
assume(x0 <= 0);


Transition 5:
assume(x0 >= 0);



----------------------------------------

(8)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := nondet();
assume(0 = 0);
x0 := oldX1;
TO: 2;

FROM: 3;
oldX0 := x0;
oldX1 := x0 - 1;
assume(0 = 0 && -1 - -(x0) = x0 - 1);
assume(x0 <= 0);
x0 := x0 - 1;
TO: 4;

FROM: 5;
oldX0 := x0;
oldX1 := x0 + 1;
assume(0 = 0 && x0 + 1 = x0 + 1);
assume(x0 >= 0);
assume(x0 >= 0);
x0 := x0 + 1;
TO: 6;

FROM: 7;
oldX0 := x0;
assume(x0 < 0);
x0 := x0;
TO: 3;

FROM: 7;
oldX0 := x0;
assume(x0 >= 0);
x0 := x0;
TO: 5;

FROM: 4;
oldX0 := x0;
assume(0 = 0);
x0 := x0;
TO: 8;

FROM: 6;
oldX0 := x0;
assume(0 = 0);
x0 := x0;
TO: 8;

FROM: 2;
oldX0 := x0;
assume(x0 * x0 > 9);
x0 := x0;
TO: 7;

FROM: 8;
oldX0 := x0;
assume(0 = 0);
x0 := x0;
TO: 2;

FROM: 2;
oldX0 := x0;
assume(x0 * x0 <= 9);
x0 := x0;
TO: 9;


----------------------------------------

(9) TerminationGraphProcessor (SOUND)
Constructed the termination graph and obtained one non-trivial SCC.

----------------------------------------

(10)
Obligation:
Rules:
f2(x6) -> f3(x6) :|: x6 * x6 > 9
f6(x7) -> f2(x7) :|: TRUE
f7(x4) -> f6(x4) :|: TRUE
f4(x) -> f7(arith) :|: TRUE && arith = x - 1
f3(x2) -> f4(x2) :|: x2 < 0
f8(x5) -> f6(x5) :|: TRUE
f5(x9) -> f8(x10) :|: TRUE && x10 = x9 + 1
f3(x3) -> f5(x3) :|: x3 >= 0

----------------------------------------

(11) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(12)
Obligation:
Rules:
f6(x7:0) -> f6(x7:0 + 1) :|: x7:0 * x7:0 > 9 && x7:0 > -1
f6(x) -> f6(x - 1) :|: x * x > 9 && x < 0

----------------------------------------

(13) IntTRSNonPeriodicNontermProof (COMPLETE)
Normalized system to the following form:
f(pc, x7:0) -> f(1, x7:0 + 1) :|: pc = 1 && (x7:0 * x7:0 > 9 && x7:0 > -1)
f(pc, x) -> f(1, x - 1) :|: pc = 1 && (x * x > 9 && x < 0)
Proved unsatisfiability of the following formula, indicating that the system is never left after entering:
((((run2_0 = ((1 * 1)) and run2_1 = ((run1_1 * 1) + (1 * 1))) and (((run1_0 * 1)) = ((1 * 1)) and ((((run1_1 * run1_1) * 1)) > ((1 * 9)) and ((run1_1 * 1)) > ((1 * -1))))) or ((run2_0 = ((1 * 1)) and run2_1 = ((run1_1 * 1) + (1 * -1))) and (((run1_0 * 1)) = ((1 * 1)) and ((((run1_1 * run1_1) * 1)) > ((1 * 9)) and ((run1_1 * 1)) < 0)))) and (!(((run2_0 * 1)) = ((1 * 1)) and ((((run2_1 * run2_1) * 1)) > ((1 * 9)) and ((run2_1 * 1)) > ((1 * -1)))) and !(((run2_0 * 1)) = ((1 * 1)) and ((((run2_1 * run2_1) * 1)) > ((1 * 9)) and ((run2_1 * 1)) < 0))))
Proved satisfiability of the following formula, indicating that the system is entered at least once:
(((run2_0 = ((1 * 1)) and run2_1 = ((run1_1 * 1) + (1 * 1))) and (((run1_0 * 1)) = ((1 * 1)) and ((((run1_1 * run1_1) * 1)) > ((1 * 9)) and ((run1_1 * 1)) > ((1 * -1))))) or ((run2_0 = ((1 * 1)) and run2_1 = ((run1_1 * 1) + (1 * -1))) and (((run1_0 * 1)) = ((1 * 1)) and ((((run1_1 * run1_1) * 1)) > ((1 * 9)) and ((run1_1 * 1)) < 0))))

----------------------------------------

(14)
NO

----------------------------------------

(15) CToLLVMProof (EQUIVALENT)
Compiled c-file /export/starexec/sandbox2/benchmark/theBenchmark.c to LLVM.
----------------------------------------

(16)
Obligation:
LLVM Problem

Aliases:

Data layout:

"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"

Machine:

"x86_64-pc-linux-gnu"

Type definitions:

Global variables:

Function declarations and definitions:

*BasicFunctionTypename: "__VERIFIER_nondet_int" returnParam: i32 parameters: () variableLength: false visibilityType: DEFAULT callingConvention: ccc
*BasicFunctionTypename: "main" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: () variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%i = alloca i32, align 4
		store 0, %1
		%2 = call i32 @__VERIFIER_nondet_int()
		store %2, %i
		br %3
	3:
		%4 = load %i
		%5 = load %i
		%6 = mul %4 %5
		%7 = icmp sgt %6 9
		br %7, %8, %18
	8:
		%9 = load %i
		%10 = icmp slt %9 0
		br %10, %11, %14
	11:
		%12 = load %i
		%13 = sub %12 1
		store %13, %i
		br %17
	14:
		%15 = load %i
		%16 = add %15 1
		store %16, %i
		br %17
	17:
		br %3
	18:
		ret 0


Analyze Termination of all function calls matching the pattern:
main()
----------------------------------------

(17) LLVMToTerminationGraphProof (EQUIVALENT)
Constructed symbolic execution graph for LLVM program and proved memory safety.
----------------------------------------

(18)
Obligation:
SE Graph
----------------------------------------

(19) SymbolicExecutionGraphToLassoProof (EQUIVALENT)
Converted SEGraph to 2 independent lassos.
----------------------------------------

(20)
Complex Obligation (AND)

----------------------------------------

(21)
Obligation:
Lasso
----------------------------------------

(22) Lasso2IRS (EQUIVALENT)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 38 rulesP rules:
f_180(v82, v83, v84, v88, v85, v86, 1, v89, v90, 0, 3, 10, 2, 4) -> f_182(v82, v83, v84, v88, v86, 1, v85, v89, v90, 0, 3, 10, 2, 4) :|: 0 = 0
f_182(v82, v83, v84, v88, v86, 1, v85, v89, v90, 0, 3, 10, 2, 4) -> f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) :|: v94 = v88 * v88
f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) -> f_186(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 9 < v94
f_186(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_190(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_190(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_194(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_194(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_198(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_198(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_200(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_200(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_202(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_202(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_204(v82, v83, v84, v88, v94, 1, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_204(v82, v83, v84, v88, v94, 1, v89, v90, 0, 3, 2, 4, 10) -> f_206(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: 1 + v100 = v88 && 3 + v100 <= 0
f_206(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_208(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_208(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_210(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_210(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_212(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_212(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_178(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 10, 2, 4) :|: TRUE
f_178(v82, v83, v84, v85, v86, 1, v88, v89, v90, 0, 3, 10, 2, 4) -> f_180(v82, v83, v84, v88, v85, v86, 1, v89, v90, 0, 3, 10, 2, 4) :|: 0 = 0
f_75 -> f_76(v1, v2, 3, 1, 4) :|: 1 <= v1 && v2 = 3 + v1 && 4 <= v2
f_76(v1, v2, 3, 1, 4) -> f_77(v1, v3, v2, v4, 3, 1, 4) :|: 1 <= v3 && v4 = 3 + v3 && 4 <= v4
f_77(v1, v3, v2, v4, 3, 1, 4) -> f_78(v1, v3, v2, v4, 0, 3, 1, 4) :|: TRUE
f_78(v1, v3, v2, v4, 0, 3, 1, 4) -> f_79(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_79(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_80(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_80(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_81(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_81(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_82(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: 0 = 0
f_82(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_83(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: 0 = 0
f_83(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) :|: v7 = v5 * v5
f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) -> f_85(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 10) :|: 9 < v7
f_85(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 10) -> f_87(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_87(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_89(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: TRUE
f_89(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_92(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: v5 < 0
f_92(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_94(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_94(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_96(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: TRUE
f_96(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_98(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_98(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_100(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: 1 + v8 = v5 && 2 + v8 <= 0
f_100(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_102(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: TRUE
f_102(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_104(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: TRUE
f_104(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_106(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: TRUE
f_106(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_142(v1, v3, v5, v5, v7, 1, v8, v2, v4, 0, 3, 10, 2, 4) :|: TRUE
f_142(v42, v43, v44, v45, v46, 1, v48, v49, v50, 0, 3, 10, 2, 4) -> f_178(v42, v43, v44, v45, v46, 1, v48, v49, v50, 0, 3, 10, 2, 4) :|: TRUE
Combined rules. Obtained 2 rulesP rules:
f_75 -> f_180(v1:0, v3:0, 1 + v8:0, v8:0, 1 + v8:0, (1 + v8:0) * (1 + v8:0), 1, 3 + v1:0, 3 + v3:0, 0, 3, 10, 2, 4) :|: v3:0 > 0 && v1:0 > 0 && 9 < (1 + v8:0) * (1 + v8:0) && v8:0 < -1
f_180(v82:0, v83:0, v84:0, 1 + v100:0, v85:0, v86:0, 1, v89:0, v90:0, 0, 3, 10, 2, 4) -> f_180(v82:0, v83:0, v84:0, v100:0, 1 + v100:0, (1 + v100:0) * (1 + v100:0), 1, v89:0, v90:0, 0, 3, 10, 2, 4) :|: v100:0 < -2 && 9 < (1 + v100:0) * (1 + v100:0)
Filtered unneeded arguments:
   f_180(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> f_180(x4)
Removed division, modulo operations, cleaned up constraints. Obtained 2 rules.P rules:
f_75 -> f_180(v8:0) :|: 9 < 1 + v8:0 + (v8:0 + v8:0 * v8:0) && v8:0 < -1
f_180(sum~cons_1~v100:0) -> f_180(v100:0) :|: v100:0 < -2 && 9 < 1 + v100:0 + (v100:0 + v100:0 * v100:0) && sum~cons_1~v100:0 = 1 + v100:0

----------------------------------------

(23)
Obligation:
Rules:
f_75 -> f_180(v8:0) :|: 9 < 1 + v8:0 + (v8:0 + v8:0 * v8:0) && v8:0 < -1
f_180(sum~cons_1~v100:0) -> f_180(v100:0) :|: v100:0 < -2 && 9 < 1 + v100:0 + (v100:0 + v100:0 * v100:0) && sum~cons_1~v100:0 = 1 + v100:0
Start term: f_75

----------------------------------------

(24) IRS2T2 (EQUIVALENT)
Transformed input IRS into an integer transition system.Used the following mapping from defined symbols to location IDs:

   (f_75_1,1)
   (f_180_1,2)

----------------------------------------

(25)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := nondet();
assume(9 < 1 + oldX1 + (oldX1 + oldX1 * oldX1) && oldX1 < -1);
x0 := oldX1;
TO: 2;

FROM: 2;
oldX0 := x0;
oldX1 := oldX0 - 1;
assume(oldX1 < -2 && 9 < 1 + oldX1 + (oldX1 + oldX1 * oldX1) && oldX0 = 1 + oldX1);
x0 := oldX0 - 1;
TO: 2;


----------------------------------------

(26) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 2:
assume(x0 <= 0);



----------------------------------------

(27)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := nondet();
assume(9 < 1 + oldX1 + (oldX1 + oldX1 * oldX1) && oldX1 < -1);
x0 := oldX1;
TO: 2;

FROM: 2;
oldX0 := x0;
oldX1 := x0 - 1;
assume(x0 - 1 < -2 && 9 < 1 + (x0 - 1) + (x0 - 1 + (x0 - 1) * (x0 - 1)) && x0 = 1 + (x0 - 1));
assume(x0 <= 0);
x0 := x0 - 1;
TO: 2;


----------------------------------------

(28) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 2:
assume(x0 <= 0);



----------------------------------------

(29)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := nondet();
assume(9 < 1 + oldX1 + (oldX1 + oldX1 * oldX1) && oldX1 < -1);
x0 := oldX1;
TO: 2;

FROM: 2;
oldX0 := x0;
oldX1 := x0 - 1;
assume(x0 - 1 < -2 && 9 < 1 + (x0 - 1) + (x0 - 1 + (x0 - 1) * (x0 - 1)) && x0 = 1 + (x0 - 1));
assume(x0 <= 0);
assume(x0 <= 0);
x0 := x0 - 1;
TO: 2;


----------------------------------------

(30)
Obligation:
Lasso
----------------------------------------

(31) Lasso2IRS (EQUIVALENT)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 37 rulesP rules:
f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) -> f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) -> f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) :|: v95 = v73 * v73
f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) -> f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 9 < v95
f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: TRUE
f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: TRUE
f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) -> f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: v101 = 1 + v73 && 2 <= v101
f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_176(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 10, 4) :|: TRUE
f_176(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) :|: TRUE
f_75 -> f_76(v1, v2, 3, 1, 4) :|: 1 <= v1 && v2 = 3 + v1 && 4 <= v2
f_76(v1, v2, 3, 1, 4) -> f_77(v1, v3, v2, v4, 3, 1, 4) :|: 1 <= v3 && v4 = 3 + v3 && 4 <= v4
f_77(v1, v3, v2, v4, 3, 1, 4) -> f_78(v1, v3, v2, v4, 0, 3, 1, 4) :|: TRUE
f_78(v1, v3, v2, v4, 0, 3, 1, 4) -> f_79(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_79(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_80(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_80(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_81(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_81(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_82(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: 0 = 0
f_82(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_83(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: 0 = 0
f_83(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) :|: v7 = v5 * v5
f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) -> f_85(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 10) :|: 9 < v7
f_85(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 10) -> f_87(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_87(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_89(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: TRUE
f_89(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_93(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 <= v5
f_93(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_95(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) :|: 0 = 0
f_95(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) -> f_97(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) :|: TRUE
f_97(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) -> f_99(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) :|: 0 = 0
f_99(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) -> f_101(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) :|: v9 = 1 + v5 && 1 <= v9
f_101(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) -> f_103(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) :|: TRUE
f_103(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) -> f_105(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) :|: TRUE
f_105(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) -> f_140(v1, v3, v5, v5, v7, 1, 0, v9, v2, v4, 3, 10, 4) :|: TRUE
f_140(v26, v27, v28, v29, v30, 1, 0, v33, v34, v35, 3, 10, 4) -> f_176(v26, v27, v28, v29, v30, 1, 0, v33, v34, v35, 3, 10, 4) :|: TRUE
Combined rules. Obtained 2 rulesP rules:
f_179(v66:0, v67:0, v68:0, v69:0, v70:0, 1, 0, v73:0, v74:0, v75:0, 3, 10, 4) -> f_179(v66:0, v67:0, v68:0, v73:0, v73:0 * v73:0, 1, 0, 1 + v73:0, v74:0, v75:0, 3, 10, 4) :|: v73:0 > 0 && v73:0 * v73:0 > 9
f_75 -> f_179(v1:0, v3:0, v5:0, v5:0, v5:0 * v5:0, 1, 0, 1 + v5:0, 3 + v1:0, 3 + v3:0, 3, 10, 4) :|: v3:0 > 0 && v1:0 > 0 && v5:0 * v5:0 > 9 && v5:0 > -1
Filtered unneeded arguments:
   f_179(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> f_179(x8)
Removed division, modulo operations, cleaned up constraints. Obtained 2 rules.P rules:
f_179(v73:0) -> f_179(1 + v73:0) :|: v73:0 > 0 && v73:0 * v73:0 > 9
f_75 -> f_179(1 + v5:0) :|: v5:0 * v5:0 > 9 && v5:0 > -1

----------------------------------------

(32)
Obligation:
Rules:
f_179(v73:0) -> f_179(1 + v73:0) :|: v73:0 > 0 && v73:0 * v73:0 > 9
f_75 -> f_179(1 + v5:0) :|: v5:0 * v5:0 > 9 && v5:0 > -1
Start term: f_75

----------------------------------------

(33) IRS2T2 (EQUIVALENT)
Transformed input IRS into an integer transition system.Used the following mapping from defined symbols to location IDs:

   (f_179_1,1)
   (f_75_1,2)

----------------------------------------

(34)
Obligation:
START: 2;

FROM: 1;
oldX0 := x0;
assume(oldX0 > 0 && oldX0 * oldX0 > 9);
x0 := 1 + oldX0;
TO: 1;

FROM: 2;
oldX0 := x0;
oldX1 := nondet();
assume(oldX1 * oldX1 > 9 && oldX1 > -1);
x0 := 1 + oldX1;
TO: 1;


----------------------------------------

(35) T2 Underapproximation (COMPLETE)
Added the following guard statements:




----------------------------------------

(36)
Obligation:
START: 2;

FROM: 1;
oldX0 := x0;
assume(x0 > 0 && x0 * x0 > 9);
x0 := x0 + 1;
TO: 1;

FROM: 2;
oldX0 := x0;
oldX1 := nondet();
assume(oldX1 * oldX1 > 9 && oldX1 > -1);
x0 := oldX1 + 1;
TO: 1;


----------------------------------------

(37) SymbolicExecutionGraphToSCCProof (SOUND)
Splitted symbolic execution graph to 2 SCCs.
----------------------------------------

(38)
Complex Obligation (AND)

----------------------------------------

(39)
Obligation:
SCC
----------------------------------------

(40) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 15 rulesP rules:
f_180(v82, v83, v84, v88, v85, v86, 1, v89, v90, 0, 3, 10, 2, 4) -> f_182(v82, v83, v84, v88, v86, 1, v85, v89, v90, 0, 3, 10, 2, 4) :|: 0 = 0
f_182(v82, v83, v84, v88, v86, 1, v85, v89, v90, 0, 3, 10, 2, 4) -> f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) :|: v94 = v88 * v88
f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) -> f_186(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 9 < v94
f_186(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_190(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_190(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_194(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_194(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_198(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_198(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_200(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_200(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_202(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_202(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_204(v82, v83, v84, v88, v94, 1, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_204(v82, v83, v84, v88, v94, 1, v89, v90, 0, 3, 2, 4, 10) -> f_206(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: 1 + v100 = v88 && 3 + v100 <= 0
f_206(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_208(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_208(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_210(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_210(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_212(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_212(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_178(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 10, 2, 4) :|: TRUE
f_178(v82, v83, v84, v85, v86, 1, v88, v89, v90, 0, 3, 10, 2, 4) -> f_180(v82, v83, v84, v88, v85, v86, 1, v89, v90, 0, 3, 10, 2, 4) :|: 0 = 0
Combined rules. Obtained 1 rulesP rules:
f_180(v82:0, v83:0, v84:0, 1 + v100:0, v85:0, v86:0, 1, v89:0, v90:0, 0, 3, 10, 2, 4) -> f_180(v82:0, v83:0, v84:0, v100:0, 1 + v100:0, (1 + v100:0) * (1 + v100:0), 1, v89:0, v90:0, 0, 3, 10, 2, 4) :|: v100:0 < -2 && 9 < (1 + v100:0) * (1 + v100:0)
Filtered unneeded arguments:
   f_180(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) -> f_180(x4)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_180(sum~cons_1~v100:0) -> f_180(v100:0) :|: v100:0 < -2 && 9 < 1 + v100:0 + (v100:0 + v100:0 * v100:0) && sum~cons_1~v100:0 = 1 + v100:0

----------------------------------------

(41)
Obligation:
Rules:
f_180(sum~cons_1~v100:0) -> f_180(v100:0) :|: v100:0 < -2 && 9 < 1 + v100:0 + (v100:0 + v100:0 * v100:0) && sum~cons_1~v100:0 = 1 + v100:0

----------------------------------------

(42) IRS2T2 (EQUIVALENT)
Transformed input IRS into an integer transition system.Used the following mapping from defined symbols to location IDs:

   (f_180_1,1)

----------------------------------------

(43)
Obligation:
START: 0;

FROM: 0;
TO: 1;

FROM: 1;
oldX0 := x0;
oldX1 := oldX0 - 1;
assume(oldX1 < -2 && 9 < 1 + oldX1 + (oldX1 + oldX1 * oldX1) && oldX0 = 1 + oldX1);
x0 := oldX0 - 1;
TO: 1;


----------------------------------------

(44) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 1:
assume(x0 <= 0);



----------------------------------------

(45)
Obligation:
START: 0;

FROM: 0;
TO: 1;

FROM: 1;
oldX0 := x0;
oldX1 := x0 - 1;
assume(x0 - 1 < -2 && 9 < 1 + (x0 - 1) + (x0 - 1 + (x0 - 1) * (x0 - 1)) && x0 = 1 + (x0 - 1));
assume(x0 <= 0);
x0 := x0 - 1;
TO: 1;


----------------------------------------

(46) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 1:
assume(x0 <= 0);



----------------------------------------

(47)
Obligation:
START: 0;

FROM: 0;
TO: 1;

FROM: 1;
oldX0 := x0;
oldX1 := x0 - 1;
assume(x0 - 1 < -2 && 9 < 1 + (x0 - 1) + (x0 - 1 + (x0 - 1) * (x0 - 1)) && x0 = 1 + (x0 - 1));
assume(x0 <= 0);
assume(x0 <= 0);
x0 := x0 - 1;
TO: 1;


----------------------------------------

(48) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(49)
Obligation:
Rules:
f_180(sum~cons_1~v100:0:0) -> f_180(v100:0:0) :|: v100:0:0 < -2 && 9 < 1 + v100:0:0 + (v100:0:0 + v100:0:0 * v100:0:0) && sum~cons_1~v100:0:0 = 1 + v100:0:0

----------------------------------------

(50) TerminationGraphProcessor (EQUIVALENT)
Constructed the termination graph and obtained one non-trivial SCC.

f_180(sum~cons_1~v100:0:0) -> f_180(v100:0:0) :|: v100:0:0 < -2 && 9 < 1 + v100:0:0 + (v100:0:0 + v100:0:0 * v100:0:0) && sum~cons_1~v100:0:0 = 1 + v100:0:0
has been transformed into
f_180(sum~cons_1~v100:0:0) -> f_180(v100:0:0) :|: sum~cons_1~v100:0:0 = x5 && (v100:0:0 < -2 && 9 < 1 + v100:0:0 + (v100:0:0 + v100:0:0 * v100:0:0) && sum~cons_1~v100:0:0 = 1 + v100:0:0) && x5 < -2 && 9 < 1 + x5 + (x5 + x5 * x5).


f_180(sum~cons_1~v100:0:0) -> f_180(v100:0:0) :|: sum~cons_1~v100:0:0 = x5 && (v100:0:0 < -2 && 9 < 1 + v100:0:0 + (v100:0:0 + v100:0:0 * v100:0:0) && sum~cons_1~v100:0:0 = 1 + v100:0:0) && x5 < -2 && 9 < 1 + x5 + (x5 + x5 * x5) and 
f_180(sum~cons_1~v100:0:0) -> f_180(v100:0:0) :|: sum~cons_1~v100:0:0 = x5 && (v100:0:0 < -2 && 9 < 1 + v100:0:0 + (v100:0:0 + v100:0:0 * v100:0:0) && sum~cons_1~v100:0:0 = 1 + v100:0:0) && x5 < -2 && 9 < 1 + x5 + (x5 + x5 * x5)
have been merged into the new rule
f_180(x12) -> f_180(x13) :|: x12 = x14 && (x15 < -2 && 9 < 1 + x15 + (x15 + x15 * x15) && x12 = 1 + x15) && x14 < -2 && 9 < 1 + x14 + (x14 + x14 * x14) && (x15 = x16 && (x13 < -2 && 9 < 1 + x13 + (x13 + x13 * x13) && x15 = 1 + x13) && x16 < -2 && 9 < 1 + x16 + (x16 + x16 * x16))


----------------------------------------

(51)
Obligation:
Rules:
f_180(x17) -> f_180(x18) :|: TRUE && x17 + -1 * x19 = 0 && x20 <= -3 && -2 * x20 + -1 * (x20 * x20) <= -9 && x17 + -1 * x20 = 1 && x19 <= -3 && -2 * x19 + -1 * (x19 * x19) <= -9 && x20 + -1 * x21 = 0 && x18 <= -3 && -2 * x18 + -1 * (x18 * x18) <= -9 && x20 + -1 * x18 = 1 && x21 <= -3 && -2 * x21 + -1 * (x21 * x21) <= -9

----------------------------------------

(52) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(53)
Obligation:
Rules:
f_180(x17:0) -> f_180(x18:0) :|: x21:0 < -2 && -9 >= -2 * x21:0 + -1 * (x21:0 * x21:0) && x20:0 + -1 * x18:0 = 1 && -9 >= -2 * x18:0 + -1 * (x18:0 * x18:0) && x18:0 < -2 && x20:0 + -1 * x21:0 = 0 && -9 >= -2 * x19:0 + -1 * (x19:0 * x19:0) && x19:0 < -2 && x17:0 + -1 * x20:0 = 1 && -9 >= -2 * x20:0 + -1 * (x20:0 * x20:0) && x17:0 + -1 * x19:0 = 0 && x20:0 < -2

----------------------------------------

(54)
Obligation:
SCC
----------------------------------------

(55) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 15 rulesP rules:
f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) -> f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) -> f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) :|: v95 = v73 * v73
f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) -> f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 9 < v95
f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: TRUE
f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: TRUE
f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) -> f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: v101 = 1 + v73 && 2 <= v101
f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_176(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 10, 4) :|: TRUE
f_176(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) :|: TRUE
Combined rules. Obtained 1 rulesP rules:
f_179(v66:0, v67:0, v68:0, v69:0, v70:0, 1, 0, v73:0, v74:0, v75:0, 3, 10, 4) -> f_179(v66:0, v67:0, v68:0, v73:0, v73:0 * v73:0, 1, 0, 1 + v73:0, v74:0, v75:0, 3, 10, 4) :|: v73:0 > 0 && v73:0 * v73:0 > 9
Filtered unneeded arguments:
   f_179(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> f_179(x8)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_179(v73:0) -> f_179(1 + v73:0) :|: v73:0 > 0 && v73:0 * v73:0 > 9

----------------------------------------

(56)
Obligation:
Rules:
f_179(v73:0) -> f_179(1 + v73:0) :|: v73:0 > 0 && v73:0 * v73:0 > 9

----------------------------------------

(57) IntTRSNonPeriodicNontermProof (COMPLETE)
Normalized system to the following form:
f(pc, v73:0) -> f(1, 1 + v73:0) :|: pc = 1 && (v73:0 > 0 && v73:0 * v73:0 > 9)
Proved unsatisfiability of the following formula, indicating that the system is never left after entering:
(((run2_0 = ((1 * 1)) and run2_1 = ((1 * 1) + (run1_1 * 1))) and (((run1_0 * 1)) = ((1 * 1)) and (((run1_1 * 1)) > 0 and (((run1_1 * run1_1) * 1)) > ((1 * 9))))) and !(((run2_0 * 1)) = ((1 * 1)) and (((run2_1 * 1)) > 0 and (((run2_1 * run2_1) * 1)) > ((1 * 9)))))
Proved satisfiability of the following formula, indicating that the system is entered at least once:
((run2_0 = ((1 * 1)) and run2_1 = ((1 * 1) + (run1_1 * 1))) and (((run1_0 * 1)) = ((1 * 1)) and (((run1_1 * 1)) > 0 and (((run1_1 * run1_1) * 1)) > ((1 * 9)))))

----------------------------------------

(58)
NO

----------------------------------------

(59) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 15 rulesP rules:
f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) -> f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) -> f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) :|: v95 = v73 * v73
f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) -> f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 9 < v95
f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: TRUE
f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: TRUE
f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) -> f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: v101 = 1 + v73 && 2 <= v101
f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_176(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 10, 4) :|: v68 <= v73 && 1 <= v66 && 1 <= v67 && 0 <= v68 && 0 <= v73 && 10 <= v95 && 1 <= v101 && 4 <= v74 && 4 <= v75 && v66 <= v74 && v67 <= v75
f_176(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) :|: TRUE
Combined rules. Obtained 1 rulesP rules:
f_179(v66:0, v67:0, v68:0, v69:0, v70:0, 1, 0, v73:0, v74:0, v75:0, 3, 10, 4) -> f_179(v66:0, v67:0, v68:0, v73:0, v73:0 * v73:0, 1, 0, 1 + v73:0, v74:0, v75:0, 3, 10, 4) :|: v73:0 > 0 && v66:0 > 0 && v73:0 >= v68:0 && v73:0 * v73:0 > 9 && v67:0 > 0 && v68:0 > -1 && v74:0 > 3 && v75:0 > 3 && v75:0 >= v67:0 && v74:0 >= v66:0
Filtered unneeded arguments:
   f_179(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> f_179(x1, x2, x3, x8, x9, x10)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_179(v66:0, v67:0, v68:0, v73:0, v74:0, v75:0) -> f_179(v66:0, v67:0, v68:0, 1 + v73:0, v74:0, v75:0) :|: v66:0 > 0 && v73:0 > 0 && v73:0 >= v68:0 && v73:0 * v73:0 > 9 && v67:0 > 0 && v68:0 > -1 && v74:0 > 3 && v75:0 > 3 && v74:0 >= v66:0 && v75:0 >= v67:0

----------------------------------------

(60)
Obligation:
Rules:
f_179(v66:0, v67:0, v68:0, v73:0, v74:0, v75:0) -> f_179(v66:0, v67:0, v68:0, 1 + v73:0, v74:0, v75:0) :|: v66:0 > 0 && v73:0 > 0 && v73:0 >= v68:0 && v73:0 * v73:0 > 9 && v67:0 > 0 && v68:0 > -1 && v74:0 > 3 && v75:0 > 3 && v74:0 >= v66:0 && v75:0 >= v67:0

----------------------------------------

(61) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(62)
Obligation:
Rules:
f_179(v66:0:0, v67:0:0, v68:0:0, v73:0:0, v74:0:0, v75:0:0) -> f_179(v66:0:0, v67:0:0, v68:0:0, 1 + v73:0:0, v74:0:0, v75:0:0) :|: v74:0:0 >= v66:0:0 && v75:0:0 >= v67:0:0 && v75:0:0 > 3 && v74:0:0 > 3 && v68:0:0 > -1 && v67:0:0 > 0 && v73:0:0 * v73:0:0 > 9 && v73:0:0 >= v68:0:0 && v73:0:0 > 0 && v66:0:0 > 0

----------------------------------------

(63) IntTRSNonPeriodicNontermProof (COMPLETE)
Normalized system to the following form:
f(pc, v66:0:0, v67:0:0, v68:0:0, v73:0:0, v74:0:0, v75:0:0) -> f(1, v66:0:0, v67:0:0, v68:0:0, 1 + v73:0:0, v74:0:0, v75:0:0) :|: pc = 1 && (v74:0:0 >= v66:0:0 && v75:0:0 >= v67:0:0 && v75:0:0 > 3 && v74:0:0 > 3 && v68:0:0 > -1 && v67:0:0 > 0 && v73:0:0 * v73:0:0 > 9 && v73:0:0 >= v68:0:0 && v73:0:0 > 0 && v66:0:0 > 0)
Proved unsatisfiability of the following formula, indicating that the system is never left after entering:
(((run2_0 = ((1 * 1)) and run2_1 = ((run1_1 * 1)) and run2_2 = ((run1_2 * 1)) and run2_3 = ((run1_3 * 1)) and run2_4 = ((1 * 1) + (run1_4 * 1)) and run2_5 = ((run1_5 * 1)) and run2_6 = ((run1_6 * 1))) and (((run1_0 * 1)) = ((1 * 1)) and (((((((((((run1_5 * 1)) >= ((run1_1 * 1)) and ((run1_6 * 1)) >= ((run1_2 * 1))) and ((run1_6 * 1)) > ((1 * 3))) and ((run1_5 * 1)) > ((1 * 3))) and ((run1_3 * 1)) > ((1 * -1))) and ((run1_2 * 1)) > 0) and (((run1_4 * run1_4) * 1)) > ((1 * 9))) and ((run1_4 * 1)) >= ((run1_3 * 1))) and ((run1_4 * 1)) > 0) and ((run1_1 * 1)) > 0))) and !(((run2_0 * 1)) = ((1 * 1)) and (((((((((((run2_5 * 1)) >= ((run2_1 * 1)) and ((run2_6 * 1)) >= ((run2_2 * 1))) and ((run2_6 * 1)) > ((1 * 3))) and ((run2_5 * 1)) > ((1 * 3))) and ((run2_3 * 1)) > ((1 * -1))) and ((run2_2 * 1)) > 0) and (((run2_4 * run2_4) * 1)) > ((1 * 9))) and ((run2_4 * 1)) >= ((run2_3 * 1))) and ((run2_4 * 1)) > 0) and ((run2_1 * 1)) > 0)))
Proved satisfiability of the following formula, indicating that the system is entered at least once:
((run2_0 = ((1 * 1)) and run2_1 = ((run1_1 * 1)) and run2_2 = ((run1_2 * 1)) and run2_3 = ((run1_3 * 1)) and run2_4 = ((1 * 1) + (run1_4 * 1)) and run2_5 = ((run1_5 * 1)) and run2_6 = ((run1_6 * 1))) and (((run1_0 * 1)) = ((1 * 1)) and (((((((((((run1_5 * 1)) >= ((run1_1 * 1)) and ((run1_6 * 1)) >= ((run1_2 * 1))) and ((run1_6 * 1)) > ((1 * 3))) and ((run1_5 * 1)) > ((1 * 3))) and ((run1_3 * 1)) > ((1 * -1))) and ((run1_2 * 1)) > 0) and (((run1_4 * run1_4) * 1)) > ((1 * 9))) and ((run1_4 * 1)) >= ((run1_3 * 1))) and ((run1_4 * 1)) > 0) and ((run1_1 * 1)) > 0)))

----------------------------------------

(64)
NO

----------------------------------------

(65) SEGraph to IRS (EQUIVALENT)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 71 rulesP rules:
f_75 -> f_76(v1, v2, 3, 1, 4) :|: 1 <= v1 && v2 = 3 + v1 && 4 <= v2
f_76(v1, v2, 3, 1, 4) -> f_77(v1, v3, v2, v4, 3, 1, 4) :|: 1 <= v3 && v4 = 3 + v3 && 4 <= v4
f_77(v1, v3, v2, v4, 3, 1, 4) -> f_78(v1, v3, v2, v4, 0, 3, 1, 4) :|: TRUE
f_78(v1, v3, v2, v4, 0, 3, 1, 4) -> f_79(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_79(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_80(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_80(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_81(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: TRUE
f_81(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_82(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: 0 = 0
f_82(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_83(v1, v3, v5, v2, v4, 0, 3, 1, 4) :|: 0 = 0
f_83(v1, v3, v5, v2, v4, 0, 3, 1, 4) -> f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) :|: v7 = v5 * v5
f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) -> f_85(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 10) :|: 9 < v7
f_84(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4) -> f_86(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 9) :|: v7 <= 9
f_85(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 10) -> f_87(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_86(v1, v3, v5, v7, v2, v4, 0, 3, 1, 4, 9) -> f_88(v1, v3, v5, v7, 0, v2, v4, 3, 1, 4, 9) :|: 0 = 0
f_87(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_89(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: TRUE
f_88(v1, v3, v5, v7, 0, v2, v4, 3, 1, 4, 9) -> f_90(v1, v3, v5, v7, 0, v2, v4, 3, 1, 4, 9) :|: TRUE
f_89(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_92(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: v5 < 0
f_91(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_93(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 <= v5
f_92(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_94(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_93(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_95(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) :|: 0 = 0
f_94(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_96(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: TRUE
f_95(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) -> f_97(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) :|: TRUE
f_96(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_98(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) :|: 0 = 0
f_97(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) -> f_99(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) :|: 0 = 0
f_98(v1, v3, v5, v7, 1, v2, v4, 0, 3, 4, 10) -> f_100(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: 1 + v8 = v5 && 2 + v8 <= 0
f_99(v1, v3, v5, v7, 1, 0, v2, v4, 3, 4, 10) -> f_101(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) :|: v9 = 1 + v5 && 1 <= v9
f_100(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_102(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: TRUE
f_101(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) -> f_103(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) :|: TRUE
f_102(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_104(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: TRUE
f_103(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) -> f_105(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) :|: TRUE
f_104(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_106(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) :|: TRUE
f_105(v1, v3, v5, v7, 1, 0, v9, v2, v4, 3, 4, 10) -> f_140(v1, v3, v5, v5, v7, 1, 0, v9, v2, v4, 3, 10, 4) :|: TRUE
f_106(v1, v3, v5, v7, 1, v8, v2, v4, 0, 3, 4, 10, 2) -> f_142(v1, v3, v5, v5, v7, 1, v8, v2, v4, 0, 3, 10, 2, 4) :|: TRUE
f_140(v26, v27, v28, v29, v30, 1, 0, v33, v34, v35, 3, 10, 4) -> f_176(v26, v27, v28, v29, v30, 1, 0, v33, v34, v35, 3, 10, 4) :|: TRUE
f_142(v42, v43, v44, v45, v46, 1, v48, v49, v50, 0, 3, 10, 2, 4) -> f_178(v42, v43, v44, v45, v46, 1, v48, v49, v50, 0, 3, 10, 2, 4) :|: TRUE
f_176(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) :|: TRUE
f_178(v82, v83, v84, v85, v86, 1, v88, v89, v90, 0, 3, 10, 2, 4) -> f_180(v82, v83, v84, v88, v85, v86, 1, v89, v90, 0, 3, 10, 2, 4) :|: 0 = 0
f_179(v66, v67, v68, v69, v70, 1, 0, v73, v74, v75, 3, 10, 4) -> f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_180(v82, v83, v84, v88, v85, v86, 1, v89, v90, 0, 3, 10, 2, 4) -> f_182(v82, v83, v84, v88, v86, 1, v85, v89, v90, 0, 3, 10, 2, 4) :|: 0 = 0
f_181(v66, v67, v68, v73, v69, v70, 1, 0, v74, v75, 3, 10, 4) -> f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) :|: 0 = 0
f_182(v82, v83, v84, v88, v86, 1, v85, v89, v90, 0, 3, 10, 2, 4) -> f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) :|: v94 = v88 * v88
f_183(v66, v67, v68, v73, v70, 1, v69, 0, v74, v75, 3, 10, 4) -> f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) :|: v95 = v73 * v73
f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) -> f_186(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 9 < v94
f_184(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4) -> f_187(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 9) :|: v94 <= 9
f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) -> f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 9 < v95
f_185(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4) -> f_189(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 9) :|: v95 <= 9
f_186(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_190(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_187(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 9) -> f_191(v82, v83, v84, v88, v94, 0, v85, 1, v89, v90, 3, 2, 4, 9) :|: 0 = 0
f_188(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_189(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 9) -> f_193(v66, v67, v68, v73, v95, 0, v69, v74, v75, 3, 1, 4, 9) :|: 0 = 0
f_190(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_194(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_191(v82, v83, v84, v88, v94, 0, v85, 1, v89, v90, 3, 2, 4, 9) -> f_195(v82, v83, v84, v88, v94, 0, v85, 1, v89, v90, 3, 2, 4, 9) :|: TRUE
f_192(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) :|: TRUE
f_193(v66, v67, v68, v73, v95, 0, v69, v74, v75, 3, 1, 4, 9) -> f_197(v66, v67, v68, v73, v95, 0, v69, v74, v75, 3, 1, 4, 9) :|: TRUE
f_194(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_198(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_196(v66, v67, v68, v73, v95, 1, v69, 0, v74, v75, 3, 4, 10) -> f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_198(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_200(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_199(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: 0 = 0
f_200(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_202(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_201(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) :|: TRUE
f_202(v82, v83, v84, v88, v94, 1, v85, v89, v90, 0, 3, 2, 4, 10) -> f_204(v82, v83, v84, v88, v94, 1, v89, v90, 0, 3, 2, 4, 10) :|: 0 = 0
f_203(v66, v67, v68, v73, v95, 1, 0, v69, v74, v75, 3, 4, 10) -> f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) :|: 0 = 0
f_204(v82, v83, v84, v88, v94, 1, v89, v90, 0, 3, 2, 4, 10) -> f_206(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: 1 + v100 = v88 && 3 + v100 <= 0
f_205(v66, v67, v68, v73, v95, 1, 0, v74, v75, 3, 4, 10) -> f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: v101 = 1 + v73 && 2 <= v101
f_206(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_208(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_207(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_208(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_210(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_209(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) :|: TRUE
f_210(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_212(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) :|: TRUE
f_211(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 4, 10, 2) -> f_176(v66, v67, v68, v73, v95, 1, 0, v101, v74, v75, 3, 10, 4) :|: TRUE
f_212(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 2, 4, 10) -> f_178(v82, v83, v84, v88, v94, 1, v100, v89, v90, 0, 3, 10, 2, 4) :|: TRUE
Combined rules. Obtained 7 rulesP rules:
f_75 -> f_90(v1:0, v3:0, v5:0, v5:0 * v5:0, 0, 3 + v1:0, 3 + v3:0, 3, 1, 4, 9) :|: v3:0 > 0 && v1:0 > 0 && v5:0 * v5:0 < 10
f_75 -> f_184(v1:0, v3:0, 1 + v8:0, v8:0, v8:0 * v8:0, 1, 1 + v8:0, 3 + v1:0, 3 + v3:0, 0, 3, 2, 4) :|: v3:0 > 0 && v1:0 > 0 && 9 < (1 + v8:0) * (1 + v8:0) && v8:0 < -1
f_184(v82:0, v83:0, v84:0, 1 + v100:0, v94:0, 1, v85:0, v89:0, v90:0, 0, 3, 2, 4) -> f_184(v82:0, v83:0, v84:0, v100:0, v100:0 * v100:0, 1, 1 + v100:0, v89:0, v90:0, 0, 3, 2, 4) :|: v100:0 < -2 && v94:0 > 9
f_75 -> f_185(v1:0, v3:0, v5:0, 1 + v5:0, (1 + v5:0) * (1 + v5:0), 1, v5:0, 0, 3 + v1:0, 3 + v3:0, 3, 4) :|: v3:0 > 0 && v1:0 > 0 && v5:0 * v5:0 > 9 && v5:0 > -1
f_184(v82:0, v83:0, v84:0, v88:0, v94:0, 1, v85:0, v89:0, v90:0, 0, 3, 2, 4) -> f_195(v82:0, v83:0, v84:0, v88:0, v94:0, 0, v85:0, 1, v89:0, v90:0, 3, 2, 4, 9) :|: v94:0 < 10
f_185(v66:0, v67:0, v68:0, v73:0, v95:0, 1, v69:0, 0, v74:0, v75:0, 3, 4) -> f_197(v66:0, v67:0, v68:0, v73:0, v95:0, 0, v69:0, v74:0, v75:0, 3, 1, 4, 9) :|: v95:0 < 10
f_185(v66:0, v67:0, v68:0, v73:0, v95:0, 1, v69:0, 0, v74:0, v75:0, 3, 4) -> f_185(v66:0, v67:0, v68:0, 1 + v73:0, (1 + v73:0) * (1 + v73:0), 1, v73:0, 0, v74:0, v75:0, 3, 4) :|: v73:0 > 0 && v95:0 > 9
Filtered unneeded arguments:
   f_184(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) -> f_184(x4, x5)
   f_185(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) -> f_185(x4, x5)
Removed division, modulo operations, cleaned up constraints. Obtained 7 rules.P rules:
f_75 -> f_90(v1:0, v3:0, v5:0, v5:0 * v5:0, 0, 3 + v1:0, 3 + v3:0, 3, 1, 4, 9) :|: v1:0 > 0 && v5:0 * v5:0 < 10 && v3:0 > 0
f_75 -> f_184(v8:0, v8:0 * v8:0) :|: 9 < 1 + v8:0 + (v8:0 + v8:0 * v8:0) && v8:0 < -1
f_184(sum~cons_1~v100:0, v94:0) -> f_184(v100:0, v100:0 * v100:0) :|: v100:0 < -2 && v94:0 > 9 && sum~cons_1~v100:0 = 1 + v100:0
f_75 -> f_185(1 + v5:0, 1 + v5:0 + (v5:0 + v5:0 * v5:0)) :|: v5:0 * v5:0 > 9 && v5:0 > -1
f_184(v88:0, v94:0) -> f_195(v82:0, v83:0, v84:0, v88:0, v94:0, 0, v85:0, 1, v89:0, v90:0, 3, 2, 4, 9) :|: v94:0 < 10
f_185(v73:0, v95:0) -> f_197(v66:0, v67:0, v68:0, v73:0, v95:0, 0, v69:0, v74:0, v75:0, 3, 1, 4, 9) :|: v95:0 < 10
f_185(v73:0, v95:0) -> f_185(1 + v73:0, 1 + v73:0 + (v73:0 + v73:0 * v73:0)) :|: v73:0 > 0 && v95:0 > 9

----------------------------------------

(66)
Obligation:
Rules:
f_75 -> f_90(v1:0, v3:0, v5:0, v5:0 * v5:0, 0, 3 + v1:0, 3 + v3:0, 3, 1, 4, 9) :|: v1:0 > 0 && v5:0 * v5:0 < 10 && v3:0 > 0
f_75 -> f_184(v8:0, v8:0 * v8:0) :|: 9 < 1 + v8:0 + (v8:0 + v8:0 * v8:0) && v8:0 < -1
f_184(sum~cons_1~v100:0, v94:0) -> f_184(v100:0, v100:0 * v100:0) :|: v100:0 < -2 && v94:0 > 9 && sum~cons_1~v100:0 = 1 + v100:0
f_75 -> f_185(1 + x, 1 + x + (x + x * x)) :|: x * x > 9 && x > -1
f_184(x1, x2) -> f_195(x3, x4, x5, x1, x2, 0, x6, 1, x7, x8, 3, 2, 4, 9) :|: x2 < 10
f_185(v73:0, v95:0) -> f_197(v66:0, v67:0, v68:0, v73:0, v95:0, 0, v69:0, v74:0, v75:0, 3, 1, 4, 9) :|: v95:0 < 10
f_185(x9, x10) -> f_185(1 + x9, 1 + x9 + (x9 + x9 * x9)) :|: x9 > 0 && x10 > 9
Start term: f_75

----------------------------------------

(67) IRS2T2 (EQUIVALENT)
Transformed input IRS into an integer transition system.Used the following mapping from defined symbols to location IDs:

   (f_75_14,1)
   (f_90_14,2)
   (f_184_14,3)
   (f_185_14,4)
   (f_195_14,5)
   (f_197_14,6)

----------------------------------------

(68)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
assume(oldX14 > 0 && oldX16 * oldX16 < 10 && oldX15 > 0);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX16 * oldX16;
x4 := 0;
x5 := 3 + oldX14;
x6 := 3 + oldX15;
x7 := 3;
x8 := 1;
x9 := 4;
x10 := 9;
x11 := oldX17;
x12 := oldX18;
x13 := oldX19;
TO: 2;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(9 < 1 + oldX14 + (oldX14 + oldX14 * oldX14) && oldX14 < -1);
x0 := oldX14;
x1 := oldX14 * oldX14;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 3;

FROM: 3;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := oldX0 - 1;
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(oldX14 < -2 && oldX1 > 9 && oldX0 = 1 + oldX14);
x0 := oldX0 - 1;
x1 := oldX14 * oldX14;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 3;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(oldX14 * oldX14 > 9 && oldX14 > -1);
x0 := 1 + oldX14;
x1 := 1 + oldX14 + (oldX14 + oldX14 * oldX14);
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 4;

FROM: 3;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
assume(oldX1 < 10);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX0;
x4 := oldX1;
x5 := 0;
x6 := oldX17;
x7 := 1;
x8 := oldX18;
x9 := oldX19;
x10 := 3;
x11 := 2;
x12 := 4;
x13 := 9;
TO: 5;

FROM: 4;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
assume(oldX1 < 10);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX0;
x4 := oldX1;
x5 := 0;
x6 := oldX17;
x7 := oldX18;
x8 := oldX19;
x9 := 3;
x10 := 1;
x11 := 4;
x12 := 9;
x13 := oldX20;
TO: 6;

FROM: 4;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
assume(oldX0 > 0 && oldX1 > 9);
x0 := 1 + oldX0;
x1 := 1 + oldX0 + (oldX0 + oldX0 * oldX0);
x2 := oldX14;
x3 := oldX15;
x4 := oldX16;
x5 := oldX17;
x6 := oldX18;
x7 := oldX19;
x8 := oldX20;
x9 := oldX21;
x10 := oldX22;
x11 := oldX23;
x12 := oldX24;
x13 := oldX25;
TO: 4;


----------------------------------------

(69) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 3:
assume(x0 <= 0);



----------------------------------------

(70)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
assume(oldX14 > 0 && oldX16 * oldX16 < 10 && oldX15 > 0);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX16 * oldX16;
x4 := 0;
x5 := oldX14 + 3;
x6 := oldX15 + 3;
x7 := 3;
x8 := 1;
x9 := 4;
x10 := 9;
x11 := oldX17;
x12 := oldX18;
x13 := oldX19;
TO: 2;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(9 < 1 + oldX14 + (oldX14 + oldX14 * oldX14) && oldX14 < -1);
x0 := oldX14;
x1 := oldX14 * oldX14;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 3;

FROM: 3;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := x0 - 1;
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(x0 - 1 < -2 && x1 > 9 && x0 = 1 + (x0 - 1));
assume(x0 <= 0);
x0 := x0 - 1;
x1 := oldX14 * oldX14;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 3;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(oldX14 * oldX14 > 9 && oldX14 > -1);
x0 := oldX14 + 1;
x1 := oldX14 + (oldX14 + oldX14 * oldX14) + 1;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 4;

FROM: 3;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
assume(x1 < 10);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX0;
x4 := oldX1;
x5 := 0;
x6 := oldX17;
x7 := 1;
x8 := oldX18;
x9 := oldX19;
x10 := 3;
x11 := 2;
x12 := 4;
x13 := 9;
TO: 5;

FROM: 4;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
assume(x1 < 10);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX0;
x4 := oldX1;
x5 := 0;
x6 := oldX17;
x7 := oldX18;
x8 := oldX19;
x9 := 3;
x10 := 1;
x11 := 4;
x12 := 9;
x13 := oldX20;
TO: 6;

FROM: 4;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
assume(x0 > 0 && x1 > 9);
x0 := x0 + 1;
x1 := oldX0 + (oldX0 + oldX0 * oldX0) + 1;
x2 := oldX14;
x3 := oldX15;
x4 := oldX16;
x5 := oldX17;
x6 := oldX18;
x7 := oldX19;
x8 := oldX20;
x9 := oldX21;
x10 := oldX22;
x11 := oldX23;
x12 := oldX24;
x13 := oldX25;
TO: 4;


----------------------------------------

(71) T2 Underapproximation (COMPLETE)
Added the following guard statements:



Transition 3:
assume(x0 <= 0);



----------------------------------------

(72)
Obligation:
START: 1;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
assume(oldX14 > 0 && oldX16 * oldX16 < 10 && oldX15 > 0);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX16 * oldX16;
x4 := 0;
x5 := oldX14 + 3;
x6 := oldX15 + 3;
x7 := 3;
x8 := 1;
x9 := 4;
x10 := 9;
x11 := oldX17;
x12 := oldX18;
x13 := oldX19;
TO: 2;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(9 < 1 + oldX14 + (oldX14 + oldX14 * oldX14) && oldX14 < -1);
x0 := oldX14;
x1 := oldX14 * oldX14;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 3;

FROM: 3;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := x0 - 1;
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(x0 - 1 < -2 && x1 > 9 && x0 = 1 + (x0 - 1));
assume(x0 <= 0);
assume(x0 <= 0);
x0 := x0 - 1;
x1 := oldX14 * oldX14;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 3;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
oldX26 := nondet();
assume(oldX14 * oldX14 > 9 && oldX14 > -1);
x0 := oldX14 + 1;
x1 := oldX14 + (oldX14 + oldX14 * oldX14) + 1;
x2 := oldX15;
x3 := oldX16;
x4 := oldX17;
x5 := oldX18;
x6 := oldX19;
x7 := oldX20;
x8 := oldX21;
x9 := oldX22;
x10 := oldX23;
x11 := oldX24;
x12 := oldX25;
x13 := oldX26;
TO: 4;

FROM: 3;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
assume(x1 < 10);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX0;
x4 := oldX1;
x5 := 0;
x6 := oldX17;
x7 := 1;
x8 := oldX18;
x9 := oldX19;
x10 := 3;
x11 := 2;
x12 := 4;
x13 := 9;
TO: 5;

FROM: 4;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
assume(x1 < 10);
x0 := oldX14;
x1 := oldX15;
x2 := oldX16;
x3 := oldX0;
x4 := oldX1;
x5 := 0;
x6 := oldX17;
x7 := oldX18;
x8 := oldX19;
x9 := 3;
x10 := 1;
x11 := 4;
x12 := 9;
x13 := oldX20;
TO: 6;

FROM: 4;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := x5;
oldX6 := x6;
oldX7 := x7;
oldX8 := x8;
oldX9 := x9;
oldX10 := x10;
oldX11 := x11;
oldX12 := x12;
oldX13 := x13;
oldX14 := nondet();
oldX15 := nondet();
oldX16 := nondet();
oldX17 := nondet();
oldX18 := nondet();
oldX19 := nondet();
oldX20 := nondet();
oldX21 := nondet();
oldX22 := nondet();
oldX23 := nondet();
oldX24 := nondet();
oldX25 := nondet();
assume(x0 > 0 && x1 > 9);
x0 := x0 + 1;
x1 := oldX0 + (oldX0 + oldX0 * oldX0) + 1;
x2 := oldX14;
x3 := oldX15;
x4 := oldX16;
x5 := oldX17;
x6 := oldX18;
x7 := oldX19;
x8 := oldX20;
x9 := oldX21;
x10 := oldX22;
x11 := oldX23;
x12 := oldX24;
x13 := oldX25;
TO: 4;