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


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


YES
proof of /export/starexec/sandbox2/benchmark/theBenchmark.c
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


Termination of the given C Problem could be proven:

(0) C Problem
(1) CToLLVMProof [EQUIVALENT, 174 ms]
(2) LLVM problem
(3) LLVMToTerminationGraphProof [EQUIVALENT, 1492 ms]
(4) LLVM Symbolic Execution Graph
(5) SymbolicExecutionGraphToSCCProof [SOUND, 0 ms]
(6) AND
    (7) LLVM Symbolic Execution SCC
        (8) SCC2IRS [SOUND, 92 ms]
        (9) IntTRS
        (10) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (11) IntTRS
        (12) RankingReductionPairProof [EQUIVALENT, 0 ms]
        (13) IntTRS
        (14) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (15) IntTRS
        (16) IntTRSUnneededArgumentFilterProof [EQUIVALENT, 0 ms]
        (17) IntTRS
        (18) PolynomialOrderProcessor [EQUIVALENT, 1 ms]
        (19) YES
    (20) LLVM Symbolic Execution SCC
        (21) SCC2IRS [SOUND, 37 ms]
        (22) IntTRS
        (23) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (24) IntTRS
        (25) RankingReductionPairProof [EQUIVALENT, 22 ms]
        (26) YES
    (27) LLVM Symbolic Execution SCC
        (28) SCC2IRS [SOUND, 78 ms]
        (29) IntTRS
        (30) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (31) IntTRS
        (32) RankingReductionPairProof [EQUIVALENT, 5 ms]
        (33) YES


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

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

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

(2)
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
		%j = alloca i32, align 4
		store 0, %1
		%2 = call i32 @__VERIFIER_nondet_int()
		store %2, %i
		%3 = call i32 @__VERIFIER_nondet_int()
		store %3, %j
		br %4
	4:
		%5 = load %i
		%6 = icmp slt %5 5
		br %6, %7, %22
	7:
		store 0, %j
		br %8
	8:
		%9 = load %i
		%10 = icmp sgt %9 2
		br %10, %11, %14
	11:
		%12 = load %j
		%13 = icmp sle %12 9
		br %14
	14:
		%15 = phi [0, %8], [%13, %11]
		br %15, %16, %19
	16:
		%17 = load %j
		%18 = add %17 1
		store %18, %j
		br %8
	19:
		%20 = load %i
		%21 = add %20 1
		store %21, %i
		br %4
	22:
		ret 0


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

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

(4)
Obligation:
SE Graph
----------------------------------------

(5) SymbolicExecutionGraphToSCCProof (SOUND)
Splitted symbolic execution graph to 3 SCCs.
----------------------------------------

(6)
Complex Obligation (AND)

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

(7)
Obligation:
SCC
----------------------------------------

(8) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 36 rulesP rules:
f_397(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1071, v1072, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 10, 2) -> f_399(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1072, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 10, 2) :|: 0 = 0
f_399(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1072, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 10, 2) -> f_401(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1112, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 2, 10) :|: v1112 = 1 + v1070 && 1 <= v1112 && v1112 <= 10
f_401(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1112, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 2, 10) -> f_403(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1112, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 2, 10) :|: TRUE
f_403(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1112, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 2, 10) -> f_405(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1112, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 2, 10) :|: TRUE
f_405(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1112, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 2, 10) -> f_406(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1073, v1070, v1112, v1074, v1075, v1076, 0, 3, 4, 2, 9, 10) :|: TRUE
f_406(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) -> f_407(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) :|: 0 = 0
f_407(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) -> f_408(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) :|: 0 = 0
f_408(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) -> f_409(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) :|: TRUE
f_409(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1150, v1151, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) -> f_410(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) :|: 0 = 0
f_410(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) -> f_411(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 8, 9) :|: v1151 <= 9 && v1150 <= 8
f_410(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 9, 10) -> f_412(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, 10, 9, v1152, v1153, v1154, 0, 3, 4, 2) :|: 9 < v1151 && v1150 = 9 && v1151 = 10 && 0 = 0
f_411(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 8, 9) -> f_413(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 8, 9) :|: 0 = 0
f_413(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 8, 9) -> f_415(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 8, 9) :|: 0 = 0
f_415(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, v1151, v1150, v1152, v1153, v1154, 0, 3, 4, 2, 8, 9) -> f_395(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1151, v1150, v1151, v1149, v1152, v1153, v1154, 0, 3, 4, 9, 10, 2) :|: TRUE
f_395(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1071, v1072, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 10, 2) -> f_397(v1063, v1064, v1065, v1066, v1067, v1068, 1, v1070, v1071, v1072, v1073, v1074, v1075, v1076, 0, 3, 4, 9, 10, 2) :|: TRUE
f_412(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, 10, 9, v1152, v1153, v1154, 0, 3, 4, 2) -> f_414(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, 10, 0, 9, v1152, v1153, v1154, 3, 4, 2) :|: 0 = 0
f_414(v1142, v1143, v1144, v1145, v1146, v1147, 1, v1149, 10, 0, 9, v1152, v1153, v1154, 3, 4, 2) -> f_416(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1149, 10, 9, v1152, v1153, v1154, 3, 4, 2) :|: 0 = 0
f_416(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1149, 10, 9, v1152, v1153, v1154, 3, 4, 2) -> f_417(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1149, 10, 9, v1152, v1153, v1154, 3, 4, 2) :|: TRUE
f_417(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1149, 10, 9, v1152, v1153, v1154, 3, 4, 2) -> f_418(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, 10, 9, v1152, v1153, v1154, 3, 4) :|: 0 = 0
f_418(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, 10, 9, v1152, v1153, v1154, 3, 4) -> f_419(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1275, 10, 9, v1152, v1153, v1154, 3, 4, 5) :|: v1275 = 1 + v1147 && 4 <= v1275 && v1275 <= 5
f_419(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1275, 10, 9, v1152, v1153, v1154, 3, 4, 5) -> f_420(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1275, 10, 9, v1152, v1153, v1154, 3, 4, 5) :|: TRUE
f_420(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1275, 10, 9, v1152, v1153, v1154, 3, 4, 5) -> f_421(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1275, 10, 9, v1152, v1153, v1154, 3, 4, 5) :|: TRUE
f_421(v1142, v1143, v1144, v1145, v1146, v1147, 1, 0, v1275, 10, 9, v1152, v1153, v1154, 3, 4, 5) -> f_422(v1142, v1143, v1144, v1145, v1146, v1275, 1, v1147, 0, 10, 9, v1152, v1153, v1154, 3, 4, 5) :|: 0 = 0
f_422(v1142, v1143, v1144, v1145, v1146, v1275, 1, v1147, 0, 10, 9, v1152, v1153, v1154, 3, 4, 5) -> f_423(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) :|: v1275 < 5 && v1147 = 3 && v1275 = 4 && 0 = 0
f_423(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) -> f_425(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) :|: 0 = 0
f_425(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) -> f_427(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) :|: TRUE
f_427(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) -> f_429(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) :|: TRUE
f_429(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) -> f_430(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) :|: TRUE
f_430(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 0, 10, 9, v1152, v1153, v1154) -> f_431(v1142, v1143, v1144, v1145, v1146, 4, 1, 3, 10, 0, 9, v1152, v1153, v1154) :|: TRUE
f_431(v1309, v1310, v1311, v1312, v1313, 4, 1, 3, 10, 0, 9, v1320, v1321, v1322) -> f_432(v1309, v1310, v1311, v1312, v1313, 4, 1, 10, 0, 9, 3, v1320, v1321, v1322) :|: 0 = 0
f_432(v1309, v1310, v1311, v1312, v1313, 4, 1, 10, 0, 9, 3, v1320, v1321, v1322) -> f_433(v1309, v1310, v1311, v1312, v1313, 4, 1, 10, 0, 9, 3, v1320, v1321, v1322) :|: 0 = 0
f_433(v1309, v1310, v1311, v1312, v1313, 4, 1, 10, 0, 9, 3, v1320, v1321, v1322) -> f_434(v1309, v1310, v1311, v1312, v1313, 4, 1, 10, 0, 9, 3, v1320, v1321, v1322) :|: TRUE
f_434(v1309, v1310, v1311, v1312, v1313, 4, 1, 10, 0, 9, 3, v1320, v1321, v1322) -> f_435(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322) :|: 0 = 0
f_435(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322) -> f_436(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322) :|: 0 = 0
f_436(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322) -> f_437(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322) :|: 0 = 0
f_437(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322) -> f_395(v1309, v1310, v1311, v1312, v1313, 4, 1, 0, 9, 10, 3, v1320, v1321, v1322, 0, 3, 4, 9, 10, 2) :|: TRUE
Combined rules. Obtained 2 rulesP rules:
f_397(v1063:0, v1064:0, v1065:0, v1066:0, v1067:0, v1068:0, 1, v1070:0, v1071:0, v1072:0, v1073:0, v1074:0, v1075:0, v1076:0, 0, 3, 4, 9, 10, 2) -> f_397(v1063:0, v1064:0, v1065:0, v1066:0, v1067:0, v1068:0, 1, 1 + v1070:0, v1070:0, 1 + v1070:0, v1073:0, v1074:0, v1075:0, v1076:0, 0, 3, 4, 9, 10, 2) :|: v1070:0 > -1 && v1070:0 < 10 && v1070:0 < 9
f_397(v1063:0, v1064:0, v1065:0, v1066:0, v1067:0, 3, 1, 9, v1071:0, v1072:0, v1073:0, v1074:0, v1075:0, v1076:0, 0, 3, 4, 9, 10, 2) -> f_397(v1063:0, v1064:0, v1065:0, v1066:0, v1067:0, 4, 1, 0, 9, 10, 3, v1074:0, v1075:0, v1076:0, 0, 3, 4, 9, 10, 2) :|: TRUE
Filtered unneeded arguments:
   f_397(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) -> f_397(x6, x8)
Removed division, modulo operations, cleaned up constraints. Obtained 2 rules.P rules:
f_397(v1068:0, v1070:0) -> f_397(v1068:0, 1 + v1070:0) :|: v1070:0 < 10 && v1070:0 < 9 && v1070:0 > -1
f_397(cons_3, cons_9) -> f_397(4, 0) :|: TRUE && cons_3 = 3 && cons_9 = 9

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

(9)
Obligation:
Rules:
f_397(v1068:0, v1070:0) -> f_397(v1068:0, 1 + v1070:0) :|: v1070:0 < 10 && v1070:0 < 9 && v1070:0 > -1
f_397(cons_3, cons_9) -> f_397(4, 0) :|: TRUE && cons_3 = 3 && cons_9 = 9

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

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

(11)
Obligation:
Rules:
f_397(v1068:0:0, v1070:0:0) -> f_397(v1068:0:0, 1 + v1070:0:0) :|: v1070:0:0 < 10 && v1070:0:0 < 9 && v1070:0:0 > -1
f_397(cons_3, cons_9) -> f_397(4, 0) :|: TRUE && cons_3 = 3 && cons_9 = 9

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

(12) RankingReductionPairProof (EQUIVALENT)
Interpretation:
[ f_397 ] = -1*f_397_2 + -10*f_397_1

The following rules are decreasing:
f_397(v1068:0:0, v1070:0:0) -> f_397(v1068:0:0, 1 + v1070:0:0) :|: v1070:0:0 < 10 && v1070:0:0 < 9 && v1070:0:0 > -1
f_397(cons_3, cons_9) -> f_397(4, 0) :|: TRUE && cons_3 = 3 && cons_9 = 9

The following rules are bounded:
f_397(cons_3, cons_9) -> f_397(4, 0) :|: TRUE && cons_3 = 3 && cons_9 = 9


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

(13)
Obligation:
Rules:
f_397(v1068:0:0, v1070:0:0) -> f_397(v1068:0:0, 1 + v1070:0:0) :|: v1070:0:0 < 10 && v1070:0:0 < 9 && v1070:0:0 > -1

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

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

(15)
Obligation:
Rules:
f_397(v1068:0:0:0, v1070:0:0:0) -> f_397(v1068:0:0:0, 1 + v1070:0:0:0) :|: v1070:0:0:0 < 10 && v1070:0:0:0 < 9 && v1070:0:0:0 > -1

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

(16) IntTRSUnneededArgumentFilterProof (EQUIVALENT)
Some arguments are removed because they cannot influence termination. We removed arguments according to the following replacements:

   f_397(x1, x2) -> f_397(x2)

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

(17)
Obligation:
Rules:
f_397(v1070:0:0:0) -> f_397(1 + v1070:0:0:0) :|: v1070:0:0:0 < 10 && v1070:0:0:0 < 9 && v1070:0:0:0 > -1

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

(18) PolynomialOrderProcessor (EQUIVALENT)
Found the following polynomial interpretation:
[f_397(x)] = 8 - x

The following rules are decreasing:
f_397(v1070:0:0:0) -> f_397(1 + v1070:0:0:0) :|: v1070:0:0:0 < 10 && v1070:0:0:0 < 9 && v1070:0:0:0 > -1
The following rules are bounded:
f_397(v1070:0:0:0) -> f_397(1 + v1070:0:0:0) :|: v1070:0:0:0 < 10 && v1070:0:0:0 < 9 && v1070:0:0:0 > -1

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

(19)
YES

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

(20)
Obligation:
SCC
----------------------------------------

(21) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 13 rulesP rules:
f_289(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) -> f_291(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) :|: 0 = 0
f_291(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) -> f_293(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) :|: TRUE
f_293(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) -> f_295(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 9, 10) :|: 0 = 0
f_295(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 9, 10) -> f_297(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) :|: v394 <= 9 && v393 <= 8
f_297(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) -> f_300(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) :|: 0 = 0
f_300(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) -> f_303(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) :|: 0 = 0
f_303(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) -> f_306(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) :|: TRUE
f_306(v387, v388, v389, v390, v391, 1, v394, v393, v395, v396, v397, 0, 3, 4, 8, 9) -> f_310(v387, v388, v389, v390, v391, 1, v394, v395, v396, v397, 0, 3, 4, 9) :|: 0 = 0
f_310(v387, v388, v389, v390, v391, 1, v394, v395, v396, v397, 0, 3, 4, 9) -> f_313(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 2, 10) :|: v516 = 1 + v394 && 2 <= v516 && v516 <= 10
f_313(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 2, 10) -> f_316(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 2, 10) :|: TRUE
f_316(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 2, 10) -> f_319(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 2, 10) :|: TRUE
f_319(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 2, 10) -> f_287(v387, v388, v389, v390, v391, 1, v394, v516, v395, v396, v397, 0, 3, 4, 9, 10) :|: TRUE
f_287(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) -> f_289(v387, v388, v389, v390, v391, 1, v393, v394, v395, v396, v397, 0, 3, 4, 9, 10) :|: 0 = 0
Combined rules. Obtained 1 rulesP rules:
f_289(v387:0, v388:0, v389:0, v390:0, v391:0, 1, v393:0, v394:0, v395:0, v396:0, v397:0, 0, 3, 4, 9, 10) -> f_289(v387:0, v388:0, v389:0, v390:0, v391:0, 1, v394:0, 1 + v394:0, v395:0, v396:0, v397:0, 0, 3, 4, 9, 10) :|: v393:0 < 9 && v394:0 < 10 && v394:0 > 0
Filtered unneeded arguments:
   f_289(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) -> f_289(x7, x8)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_289(v393:0, v394:0) -> f_289(v394:0, 1 + v394:0) :|: v394:0 < 10 && v394:0 > 0 && v393:0 < 9

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

(22)
Obligation:
Rules:
f_289(v393:0, v394:0) -> f_289(v394:0, 1 + v394:0) :|: v394:0 < 10 && v394:0 > 0 && v393:0 < 9

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

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

(24)
Obligation:
Rules:
f_289(v393:0:0, v394:0:0) -> f_289(v394:0:0, 1 + v394:0:0) :|: v394:0:0 < 10 && v394:0:0 > 0 && v393:0:0 < 9

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

(25) RankingReductionPairProof (EQUIVALENT)
Interpretation:
[ f_289 ] = -1*f_289_2

The following rules are decreasing:
f_289(v393:0:0, v394:0:0) -> f_289(v394:0:0, 1 + v394:0:0) :|: v394:0:0 < 10 && v394:0:0 > 0 && v393:0:0 < 9

The following rules are bounded:
f_289(v393:0:0, v394:0:0) -> f_289(v394:0:0, 1 + v394:0:0) :|: v394:0:0 < 10 && v394:0:0 > 0 && v393:0:0 < 9


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

(26)
YES

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

(27)
Obligation:
SCC
----------------------------------------

(28) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 15 rulesP rules:
f_209(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) -> f_211(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) :|: 0 = 0
f_211(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) -> f_213(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) :|: TRUE
f_213(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) -> f_215(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) :|: TRUE
f_215(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) -> f_217(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) :|: TRUE
f_217(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) -> f_219(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) :|: 0 = 0
f_219(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) -> f_222(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) :|: v133 <= 2 && v130 <= 1 && v128 <= 1
f_222(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) -> f_226(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) :|: 0 = 0
f_226(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) -> f_229(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) :|: 0 = 0
f_229(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) -> f_232(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) :|: TRUE
f_232(v125, v126, v127, v128, v129, v133, 1, 0, v130, v134, v135, v136, 3, 2, 4) -> f_235(v125, v126, v127, v128, v129, v133, 1, 0, v134, v135, v136, 3, 2, 4) :|: 0 = 0
f_235(v125, v126, v127, v128, v129, v133, 1, 0, v134, v135, v136, 3, 2, 4) -> f_238(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) :|: v178 = 1 + v133 && v178 <= 3
f_238(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) -> f_241(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) :|: TRUE
f_241(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) -> f_244(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) :|: TRUE
f_244(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) -> f_207(v125, v126, v127, v128, v129, v133, 1, 0, v178, v134, v135, v136, 3, 2, 4) :|: TRUE
f_207(v125, v126, v127, v128, v129, v130, 1, 0, v133, v134, v135, v136, 3, 2, 4) -> f_209(v125, v126, v127, v128, v129, v133, 1, v130, 0, v134, v135, v136, 3, 2, 4) :|: 0 = 0
Combined rules. Obtained 1 rulesP rules:
f_209(v125:0, v126:0, v127:0, v128:0, v129:0, v133:0, 1, v130:0, 0, v134:0, v135:0, v136:0, 3, 2, 4) -> f_209(v125:0, v126:0, v127:0, v128:0, v129:0, 1 + v133:0, 1, v133:0, 0, v134:0, v135:0, v136:0, 3, 2, 4) :|: v130:0 < 2 && v133:0 < 3 && v128:0 < 2
Filtered unneeded arguments:
   f_209(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) -> f_209(x4, x6, x8)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_209(v128:0, v133:0, v130:0) -> f_209(v128:0, 1 + v133:0, v133:0) :|: v133:0 < 3 && v128:0 < 2 && v130:0 < 2

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

(29)
Obligation:
Rules:
f_209(v128:0, v133:0, v130:0) -> f_209(v128:0, 1 + v133:0, v133:0) :|: v133:0 < 3 && v128:0 < 2 && v130:0 < 2

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

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

(31)
Obligation:
Rules:
f_209(v128:0:0, v133:0:0, v130:0:0) -> f_209(v128:0:0, 1 + v133:0:0, v133:0:0) :|: v133:0:0 < 3 && v128:0:0 < 2 && v130:0:0 < 2

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

(32) RankingReductionPairProof (EQUIVALENT)
Interpretation:
[ f_209 ] = -1*f_209_2

The following rules are decreasing:
f_209(v128:0:0, v133:0:0, v130:0:0) -> f_209(v128:0:0, 1 + v133:0:0, v133:0:0) :|: v133:0:0 < 3 && v128:0:0 < 2 && v130:0:0 < 2

The following rules are bounded:
f_209(v128:0:0, v133:0:0, v130:0:0) -> f_209(v128:0:0, 1 + v133:0:0, v133:0:0) :|: v133:0:0 < 3 && v128:0:0 < 2 && v130:0:0 < 2


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

(33)
YES