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


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


YES
proof of /export/starexec/sandbox/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, 176 ms]
(2) LLVM problem
(3) LLVMToTerminationGraphProof [EQUIVALENT, 2088 ms]
(4) LLVM Symbolic Execution Graph
(5) SymbolicExecutionGraphToSCCProof [SOUND, 1 ms]
(6) AND
    (7) LLVM Symbolic Execution SCC
        (8) SCC2IRS [SOUND, 71 ms]
        (9) IntTRS
        (10) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (11) IntTRS
        (12) RankingReductionPairProof [EQUIVALENT, 25 ms]
        (13) IntTRS
        (14) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (15) IntTRS
        (16) RankingReductionPairProof [EQUIVALENT, 5 ms]
        (17) YES
    (18) LLVM Symbolic Execution SCC
        (19) SCC2IRS [SOUND, 43 ms]
        (20) IntTRS
        (21) IntTRSCompressionProof [EQUIVALENT, 2 ms]
        (22) IntTRS
        (23) RankingReductionPairProof [EQUIVALENT, 13 ms]
        (24) YES
    (25) LLVM Symbolic Execution SCC
        (26) SCC2IRS [SOUND, 58 ms]
        (27) IntTRS
        (28) TerminationGraphProcessor [EQUIVALENT, 10 ms]
        (29) YES


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

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

(1) CToLLVMProof (EQUIVALENT)
Compiled c-file /export/starexec/sandbox/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: "test_fun" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: (x i32, y i32) variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		%2 = alloca i32, align 4
		%3 = alloca i32, align 4
		store %x, %2
		store %y, %3
		br %4
	4:
		%5 = load %2
		%6 = icmp sge %5 0
		br %6, %7, %23
	7:
		store 1, %3
		br %8
	8:
		%9 = load %2
		%10 = load %3
		%11 = icmp sgt %9 %10
		br %11, %12, %20
	12:
		%13 = load %3
		%14 = icmp sle %13 0
		br %14, %15, %17
	15:
		%16 = load %2
		store %16, %1
		br %25
	17:
		%18 = load %3
		%19 = mul 2 %18
		store %19, %3
		br %8
	20:
		%21 = load %2
		%22 = sub %21 1
		store %22, %2
		br %4
	23:
		%24 = load %3
		store %24, %1
		br %25
	25:
		%26 = load %1
		ret %26

*BasicFunctionTypename: "main" linkageType: EXTERNALLY_VISIBLE returnParam: i32 parameters: () variableLength: false visibilityType: DEFAULT callingConvention: ccc
	0:
		%1 = alloca i32, align 4
		store 0, %1
		%2 = call i32 @__VERIFIER_nondet_int()
		%3 = call i32 @__VERIFIER_nondet_int()
		%4 = call i32 @test_fun(i32 %2, i32 %3)
		ret %4


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 38 rulesP rules:
f_414(v457, v458, v459, v460, v461, v462, 1, v464, 0, v465, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_415(v457, v458, v459, v460, v461, v462, 1, v464, 0, v465, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_415(v457, v458, v459, v460, v461, v462, 1, v464, 0, v465, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_416(v457, v458, v459, v460, v461, v462, 1, v464, 0, v465, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_416(v457, v458, v459, v460, v461, v462, 1, v464, 0, v465, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_417(v457, v458, v459, v460, v461, v462, 1, v464, 0, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_417(v457, v458, v459, v460, v461, v462, 1, v464, 0, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_418(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: v479 = 2 * v464 && 2 <= v479
f_418(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_419(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_419(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_420(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_420(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_421(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_421(v457, v458, v459, v460, v461, v462, 1, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_422(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_422(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_423(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: v479 < v462 && 3 <= v462 && 4 <= v468 && 4 <= v457
f_422(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_424(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: v462 <= v479
f_423(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_425(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_425(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_427(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_427(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_413(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_413(v457, v458, v459, v460, v461, v462, 1, v464, v465, 0, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_414(v457, v458, v459, v460, v461, v462, 1, v464, 0, v465, v467, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_424(v457, v458, v459, v460, v461, v462, 1, v479, v464, 0, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_426(v457, v458, v459, v460, v461, v462, 1, v479, 0, v464, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: 0 = 0
f_426(v457, v458, v459, v460, v461, v462, 1, v479, 0, v464, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_428(v457, v458, v459, v460, v461, v462, 1, v479, 0, v464, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_428(v457, v458, v459, v460, v461, v462, 1, v479, 0, v464, v468, v469, v470, v471, v472, v473, 3, 2, 4) -> f_447(v457, v458, v459, v460, v461, v462, 1, v479, 0, v464, v479, v468, v469, v470, v471, v472, v473, 3, 2, 4) :|: TRUE
f_447(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v673, v674, v675, v676, v677, v678, 3, 2, 4) -> f_448(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: 0 = 0
f_448(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_449(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v679, v674, v675, v676, v677, v678, 3, 2, 4) :|: 1 + v679 = v667 && 0 <= 1 + v679
f_449(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v679, v674, v675, v676, v677, v678, 3, 2, 4) -> f_450(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v679, v674, v675, v676, v677, v678, 3, 2, 4) :|: TRUE
f_450(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v679, v674, v675, v676, v677, v678, 3, 2, 4) -> f_451(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v679, v674, v675, v676, v677, v678, 3, 2, 4) :|: TRUE
f_451(v662, v663, v664, v665, v666, v667, 1, v669, 0, v671, v672, v679, v674, v675, v676, v677, v678, 3, 2, 4) -> f_452(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: 0 = 0
f_452(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_453(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: 0 <= v679 && 1 <= v667
f_453(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_455(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: 0 = 0
f_455(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_457(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: TRUE
f_457(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_459(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: TRUE
f_459(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_461(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: TRUE
f_461(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) -> f_438(v662, v663, v664, v665, v666, v679, 1, v667, v669, 0, v671, v672, v674, v675, v676, v677, v678, 3, 2, 4) :|: TRUE
f_438(v589, v590, v591, v592, v593, v594, 1, v596, v597, 0, v599, v600, v601, v602, v603, v604, v605, 3, 2, 4) -> f_439(v589, v590, v591, v592, v593, v594, 1, v597, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: 0 = 0
f_439(v589, v590, v591, v592, v593, v594, 1, v597, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_440(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: 0 = 0
f_440(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_441(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: 1 < v594 && 3 <= v596 && 3 <= v589 && 4 <= v600 && 2 <= v599
f_440(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_442(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: v594 <= 1 && v596 <= 2
f_441(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_443(v589, v590, v591, v592, v593, v594, 1, v599, 0, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: 0 = 0
f_443(v589, v590, v591, v592, v593, v594, 1, v599, 0, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_445(v589, v590, v591, v592, v593, v594, 1, v599, 0, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: TRUE
f_445(v589, v590, v591, v592, v593, v594, 1, v599, 0, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_413(v589, v590, v591, v592, v593, v594, 1, 1, v599, 0, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: TRUE
f_442(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_444(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: 0 = 0
f_444(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_446(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: TRUE
f_446(v589, v590, v591, v592, v593, v594, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) -> f_447(v589, v590, v591, v592, v593, v594, 1, 1, 0, v599, v600, v596, v601, v602, v603, v604, v605, 3, 2, 4) :|: TRUE
Combined rules. Obtained 4 rulesP rules:
f_440(v589:0, v590:0, v591:0, v592:0, v593:0, v594:0, 1, 0, v599:0, v600:0, v596:0, v601:0, v602:0, v603:0, v604:0, v605:0, 3, 2, 4) -> f_414(v589:0, v590:0, v591:0, v592:0, v593:0, v594:0, 1, 1, 0, v599:0, v600:0, v596:0, v601:0, v602:0, v603:0, v604:0, v605:0, 3, 2, 4) :|: v596:0 > 2 && v594:0 > 1 && v589:0 > 2 && v599:0 > 1 && v600:0 > 3
f_414(v457:0, v458:0, v459:0, v460:0, v461:0, 1 + v679:0, 1, v464:0, 0, v465:0, v467:0, v468:0, v469:0, v470:0, v471:0, v472:0, v473:0, 3, 2, 4) -> f_440(v457:0, v458:0, v459:0, v460:0, v461:0, v679:0, 1, 0, v464:0, 2 * v464:0, 1 + v679:0, v469:0, v470:0, v471:0, v472:0, v473:0, 3, 2, 4) :|: v679:0 > -1 && 2 * v464:0 > 1 && 2 * v464:0 >= 1 + v679:0
f_440(v589:0, v590:0, v591:0, v592:0, v593:0, 1 + v679:0, 1, 0, v599:0, v600:0, v596:0, v601:0, v602:0, v603:0, v604:0, v605:0, 3, 2, 4) -> f_440(v589:0, v590:0, v591:0, v592:0, v593:0, v679:0, 1, 0, v599:0, v600:0, 1 + v679:0, v601:0, v602:0, v603:0, v604:0, v605:0, 3, 2, 4) :|: v679:0 > -1 && v679:0 < 1 && v596:0 < 3
f_414(v457:0, v458:0, v459:0, v460:0, v461:0, v462:0, 1, v464:0, 0, v465:0, v467:0, v468:0, v469:0, v470:0, v471:0, v472:0, v473:0, 3, 2, 4) -> f_414(v457:0, v458:0, v459:0, v460:0, v461:0, v462:0, 1, 2 * v464:0, 0, v464:0, 2 * v464:0, v468:0, v469:0, v470:0, v471:0, v472:0, v473:0, 3, 2, 4) :|: 2 * v464:0 > 1 && v462:0 > 2 && v462:0 > 2 * v464:0 && v457:0 > 3 && v468:0 > 3
Filtered unneeded arguments:
   f_440(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) -> f_440(x1, x6, x9, x10, x11)
   f_414(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) -> f_414(x1, x6, x8, x12)
Removed division, modulo operations, cleaned up constraints. Obtained 4 rules.P rules:
f_440(v589:0, v594:0, v599:0, v600:0, v596:0) -> f_414(v589:0, v594:0, 1, v596:0) :|: v594:0 > 1 && v596:0 > 2 && v589:0 > 2 && v600:0 > 3 && v599:0 > 1
f_414(v457:0, sum~cons_1~v679:0, v464:0, v468:0) -> f_440(v457:0, v679:0, v464:0, 2 * v464:0, 1 + v679:0) :|: 2 * v464:0 > 1 && 2 * v464:0 >= 1 + v679:0 && v679:0 > -1 && sum~cons_1~v679:0 = 1 + v679:0
f_440(v589:0, sum~cons_1~v679:0, v599:0, v600:0, v596:0) -> f_440(v589:0, v679:0, v599:0, v600:0, 1 + v679:0) :|: v679:0 < 1 && v596:0 < 3 && v679:0 > -1 && sum~cons_1~v679:0 = 1 + v679:0
f_414(v457:0, v462:0, v464:0, v468:0) -> f_414(v457:0, v462:0, 2 * v464:0, v468:0) :|: v462:0 > 2 && 2 * v464:0 > 1 && v462:0 > 2 * v464:0 && v468:0 > 3 && v457:0 > 3

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

(9)
Obligation:
Rules:
f_440(v589:0, v594:0, v599:0, v600:0, v596:0) -> f_414(v589:0, v594:0, 1, v596:0) :|: v594:0 > 1 && v596:0 > 2 && v589:0 > 2 && v600:0 > 3 && v599:0 > 1
f_414(v457:0, sum~cons_1~v679:0, v464:0, v468:0) -> f_440(v457:0, v679:0, v464:0, 2 * v464:0, 1 + v679:0) :|: 2 * v464:0 > 1 && 2 * v464:0 >= 1 + v679:0 && v679:0 > -1 && sum~cons_1~v679:0 = 1 + v679:0
f_440(x, x1, x2, x3, x4) -> f_440(x, x5, x2, x3, 1 + x5) :|: x5 < 1 && x4 < 3 && x5 > -1 && x1 = 1 + x5
f_414(x6, x7, x8, x9) -> f_414(x6, x7, 2 * x8, x9) :|: x7 > 2 && 2 * x8 > 1 && x7 > 2 * x8 && x9 > 3 && x6 > 3

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

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

(11)
Obligation:
Rules:
f_414(x6:0, x7:0, x8:0, x9:0) -> f_414(x6:0, x7:0, 2 * x8:0, x9:0) :|: x9:0 > 3 && x6:0 > 3 && x7:0 > 2 * x8:0 && 2 * x8:0 > 1 && x7:0 > 2
f_440(x:0, sum~cons_1~x5:0, x2:0, x3:0, x4:0) -> f_440(x:0, x5:0, x2:0, x3:0, 1 + x5:0) :|: x5:0 < 1 && x4:0 < 3 && x5:0 > -1 && sum~cons_1~x5:0 = 1 + x5:0
f_414(v457:0:0, sum~cons_1~v679:0:0, v464:0:0, v468:0:0) -> f_440(v457:0:0, v679:0:0, v464:0:0, 2 * v464:0:0, 1 + v679:0:0) :|: 2 * v464:0:0 > 1 && 2 * v464:0:0 >= 1 + v679:0:0 && v679:0:0 > -1 && sum~cons_1~v679:0:0 = 1 + v679:0:0
f_440(v589:0:0, v594:0:0, v599:0:0, v600:0:0, v596:0:0) -> f_414(v589:0:0, v594:0:0, 1, v596:0:0) :|: v600:0:0 > 3 && v599:0:0 > 1 && v589:0:0 > 2 && v596:0:0 > 2 && v594:0:0 > 1

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

(12) RankingReductionPairProof (EQUIVALENT)
Interpretation:
[ f_414 ] = 2*f_414_2 + -1
[ f_440 ] = 2*f_440_2

The following rules are decreasing:
f_440(x:0, sum~cons_1~x5:0, x2:0, x3:0, x4:0) -> f_440(x:0, x5:0, x2:0, x3:0, 1 + x5:0) :|: x5:0 < 1 && x4:0 < 3 && x5:0 > -1 && sum~cons_1~x5:0 = 1 + x5:0
f_414(v457:0:0, sum~cons_1~v679:0:0, v464:0:0, v468:0:0) -> f_440(v457:0:0, v679:0:0, v464:0:0, 2 * v464:0:0, 1 + v679:0:0) :|: 2 * v464:0:0 > 1 && 2 * v464:0:0 >= 1 + v679:0:0 && v679:0:0 > -1 && sum~cons_1~v679:0:0 = 1 + v679:0:0
f_440(v589:0:0, v594:0:0, v599:0:0, v600:0:0, v596:0:0) -> f_414(v589:0:0, v594:0:0, 1, v596:0:0) :|: v600:0:0 > 3 && v599:0:0 > 1 && v589:0:0 > 2 && v596:0:0 > 2 && v594:0:0 > 1

The following rules are bounded:
f_414(x6:0, x7:0, x8:0, x9:0) -> f_414(x6:0, x7:0, 2 * x8:0, x9:0) :|: x9:0 > 3 && x6:0 > 3 && x7:0 > 2 * x8:0 && 2 * x8:0 > 1 && x7:0 > 2
f_440(x:0, sum~cons_1~x5:0, x2:0, x3:0, x4:0) -> f_440(x:0, x5:0, x2:0, x3:0, 1 + x5:0) :|: x5:0 < 1 && x4:0 < 3 && x5:0 > -1 && sum~cons_1~x5:0 = 1 + x5:0
f_414(v457:0:0, sum~cons_1~v679:0:0, v464:0:0, v468:0:0) -> f_440(v457:0:0, v679:0:0, v464:0:0, 2 * v464:0:0, 1 + v679:0:0) :|: 2 * v464:0:0 > 1 && 2 * v464:0:0 >= 1 + v679:0:0 && v679:0:0 > -1 && sum~cons_1~v679:0:0 = 1 + v679:0:0
f_440(v589:0:0, v594:0:0, v599:0:0, v600:0:0, v596:0:0) -> f_414(v589:0:0, v594:0:0, 1, v596:0:0) :|: v600:0:0 > 3 && v599:0:0 > 1 && v589:0:0 > 2 && v596:0:0 > 2 && v594:0:0 > 1


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

(13)
Obligation:
Rules:
f_414(x6:0, x7:0, x8:0, x9:0) -> f_414(x6:0, x7:0, 2 * x8:0, x9:0) :|: x9:0 > 3 && x6:0 > 3 && x7:0 > 2 * x8:0 && 2 * x8:0 > 1 && x7:0 > 2

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

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

(15)
Obligation:
Rules:
f_414(x6:0:0, x7:0:0, x8:0:0, x9:0:0) -> f_414(x6:0:0, x7:0:0, 2 * x8:0:0, x9:0:0) :|: 2 * x8:0:0 > 1 && x7:0:0 > 2 && x7:0:0 > 2 * x8:0:0 && x6:0:0 > 3 && x9:0:0 > 3

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

(16) RankingReductionPairProof (EQUIVALENT)
Interpretation:
[ f_414 ] = -1*f_414_3 + 1/2*f_414_2

The following rules are decreasing:
f_414(x6:0:0, x7:0:0, x8:0:0, x9:0:0) -> f_414(x6:0:0, x7:0:0, 2 * x8:0:0, x9:0:0) :|: 2 * x8:0:0 > 1 && x7:0:0 > 2 && x7:0:0 > 2 * x8:0:0 && x6:0:0 > 3 && x9:0:0 > 3

The following rules are bounded:
f_414(x6:0:0, x7:0:0, x8:0:0, x9:0:0) -> f_414(x6:0:0, x7:0:0, 2 * x8:0:0, x9:0:0) :|: 2 * x8:0:0 > 1 && x7:0:0 > 2 && x7:0:0 > 2 * x8:0:0 && x6:0:0 > 3 && x9:0:0 > 3


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

(17)
YES

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

(18)
Obligation:
SCC
----------------------------------------

(19) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 13 rulesP rules:
f_280(v101, v102, v103, v104, v105, 1, v107, 0, v109, v110, v111, v112, v113, v114, 3, 2, 4) -> f_281(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) :|: 0 = 0
f_281(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) -> f_282(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) :|: v109 < v101 && 3 <= v101
f_282(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) -> f_284(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) :|: 0 = 0
f_284(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) -> f_286(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) :|: TRUE
f_286(v101, v102, v103, v104, v105, 1, v109, v107, 0, v110, v111, v112, v113, v114, 3, 2, 4) -> f_288(v101, v102, v103, v104, v105, 1, v109, 0, v107, v110, v111, v112, v113, v114, 3, 2, 4) :|: 0 = 0
f_288(v101, v102, v103, v104, v105, 1, v109, 0, v107, v110, v111, v112, v113, v114, 3, 2, 4) -> f_290(v101, v102, v103, v104, v105, 1, v109, 0, v107, v110, v111, v112, v113, v114, 3, 2, 4) :|: 0 = 0
f_290(v101, v102, v103, v104, v105, 1, v109, 0, v107, v110, v111, v112, v113, v114, 3, 2, 4) -> f_292(v101, v102, v103, v104, v105, 1, v109, 0, v107, v110, v111, v112, v113, v114, 3, 2, 4) :|: TRUE
f_292(v101, v102, v103, v104, v105, 1, v109, 0, v107, v110, v111, v112, v113, v114, 3, 2, 4) -> f_294(v101, v102, v103, v104, v105, 1, v109, 0, v110, v111, v112, v113, v114, 3, 2, 4) :|: 0 = 0
f_294(v101, v102, v103, v104, v105, 1, v109, 0, v110, v111, v112, v113, v114, 3, 2, 4) -> f_296(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) :|: v117 = 2 * v109 && 4 <= v117
f_296(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) -> f_298(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) :|: TRUE
f_298(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) -> f_300(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) :|: TRUE
f_300(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) -> f_279(v101, v102, v103, v104, v105, 1, v109, 0, v117, v110, v111, v112, v113, v114, 3, 2, 4) :|: TRUE
f_279(v101, v102, v103, v104, v105, 1, v107, 0, v109, v110, v111, v112, v113, v114, 3, 2, 4) -> f_280(v101, v102, v103, v104, v105, 1, v107, 0, v109, v110, v111, v112, v113, v114, 3, 2, 4) :|: 0 = 0
Combined rules. Obtained 1 rulesP rules:
f_280(v101:0, v102:0, v103:0, v104:0, v105:0, 1, v107:0, 0, v109:0, v110:0, v111:0, v112:0, v113:0, v114:0, 3, 2, 4) -> f_280(v101:0, v102:0, v103:0, v104:0, v105:0, 1, v109:0, 0, 2 * v109:0, v110:0, v111:0, v112:0, v113:0, v114:0, 3, 2, 4) :|: v101:0 > 2 && 3 < 2 * v109:0 && v109:0 < v101:0
Filtered unneeded arguments:
   f_280(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) -> f_280(x1, x9)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_280(v101:0, v109:0) -> f_280(v101:0, 2 * v109:0) :|: 3 < 2 * v109:0 && v109:0 < v101:0 && v101:0 > 2

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

(20)
Obligation:
Rules:
f_280(v101:0, v109:0) -> f_280(v101:0, 2 * v109:0) :|: 3 < 2 * v109:0 && v109:0 < v101:0 && v101:0 > 2

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

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

(22)
Obligation:
Rules:
f_280(v101:0:0, v109:0:0) -> f_280(v101:0:0, 2 * v109:0:0) :|: 3 < 2 * v109:0:0 && v109:0:0 < v101:0:0 && v101:0:0 > 2

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

(23) RankingReductionPairProof (EQUIVALENT)
Interpretation:
[ f_280 ] = -1/2*f_280_2 + 1/2*f_280_1

The following rules are decreasing:
f_280(v101:0:0, v109:0:0) -> f_280(v101:0:0, 2 * v109:0:0) :|: 3 < 2 * v109:0:0 && v109:0:0 < v101:0:0 && v101:0:0 > 2

The following rules are bounded:
f_280(v101:0:0, v109:0:0) -> f_280(v101:0:0, 2 * v109:0:0) :|: 3 < 2 * v109:0:0 && v109:0:0 < v101:0:0 && v101:0:0 > 2


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

(24)
YES

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

(25)
Obligation:
SCC
----------------------------------------

(26) SCC2IRS (SOUND)
Transformed LLVM symbolic execution graph SCC into a rewrite problem. Log: 
Generated rules. Obtained 15 rulesP rules:
f_214(v16, v17, v18, v19, v20, v24, 1, v21, 0, v25, v26, v27, v28, v29, 3, 4) -> f_216(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 <= v24 && v21 = 1 && v24 = 0 && 0 = 0
f_216(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_219(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
f_219(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_223(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_223(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_227(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_227(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_231(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_231(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_235(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
f_235(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_239(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
f_239(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_243(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
f_243(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_247(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_247(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_250(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
f_250(1, v17, v18, v19, v20, 0, v25, v26, v27, v28, v29, 3, 4) -> f_253(1, v17, v18, v19, v20, 0, -1, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
f_253(1, v17, v18, v19, v20, 0, -1, v25, v26, v27, v28, v29, 3, 4) -> f_256(1, v17, v18, v19, v20, 0, -1, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_256(1, v17, v18, v19, v20, 0, -1, v25, v26, v27, v28, v29, 3, 4) -> f_258(1, v17, v18, v19, v20, 0, -1, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_258(1, v17, v18, v19, v20, 0, -1, v25, v26, v27, v28, v29, 3, 4) -> f_211(1, v17, v18, v19, v20, 0, 1, 0, -1, v25, v26, v27, v28, v29, 3, 4) :|: TRUE
f_211(v16, v17, v18, v19, v20, v21, 1, 0, v24, v25, v26, v27, v28, v29, 3, 4) -> f_214(v16, v17, v18, v19, v20, v24, 1, v21, 0, v25, v26, v27, v28, v29, 3, 4) :|: 0 = 0
Combined rules. Obtained 1 rulesP rules:
f_214(v16:0, v17:0, v18:0, v19:0, v20:0, 0, 1, 1, 0, v25:0, v26:0, v27:0, v28:0, v29:0, 3, 4) -> f_214(1, v17:0, v18:0, v19:0, v20:0, -1, 1, 0, 0, v25:0, v26:0, v27:0, v28:0, v29:0, 3, 4) :|: TRUE
Filtered unneeded arguments:
   f_214(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) -> f_214(x6, x8)
Removed division, modulo operations, cleaned up constraints. Obtained 1 rules.P rules:
f_214(cons_0, cons_1) -> f_214(-1, 0) :|: TRUE && cons_0 = 0 && cons_1 = 1

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

(27)
Obligation:
Rules:
f_214(cons_0, cons_1) -> f_214(-1, 0) :|: TRUE && cons_0 = 0 && cons_1 = 1

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

(28) TerminationGraphProcessor (EQUIVALENT)
Constructed the termination graph and obtained no non-trivial SCC(s).

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

(29)
YES