/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: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


Termination of the given C Problem could be proven:

(0) C Problem
(1) CToLLVMProof [EQUIVALENT, 179 ms]
(2) LLVM problem
(3) LLVMToTerminationGraphProof [EQUIVALENT, 2097 ms]
(4) LLVM Symbolic Execution Graph
(5) SymbolicExecutionGraphToSCCProof [SOUND, 0 ms]
(6) AND
    (7) LLVM Symbolic Execution SCC
        (8) SCC2IRS [SOUND, 55 ms]
        (9) IntTRS
        (10) IRS2T2 [EQUIVALENT, 0 ms]
        (11) T2IntSys
        (12) T2 [EQUIVALENT, 513 ms]
        (13) YES
    (14) LLVM Symbolic Execution SCC
        (15) SCC2IRS [SOUND, 23 ms]
        (16) IntTRS
        (17) IntTRSCompressionProof [EQUIVALENT, 0 ms]
        (18) IntTRS
        (19) RankingReductionPairProof [EQUIVALENT, 16 ms]
        (20) YES
    (21) LLVM Symbolic Execution SCC
        (22) SCC2IRS [SOUND, 33 ms]
        (23) IntTRS
        (24) TerminationGraphProcessor [EQUIVALENT, 12 ms]
        (25) 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) IRS2T2 (EQUIVALENT)
Transformed input IRS into an integer transition system.Used the following mapping from defined symbols to location IDs:

   (f_440_5,1)
   (f_414_5,2)

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

(11)
Obligation:
START: 0;

FROM: 0;
TO: 1;

FROM: 0;
TO: 2;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := nondet();
assume(oldX1 > 1 && oldX4 > 2 && oldX0 > 2 && oldX3 > 3 && oldX2 > 1);
x0 := oldX0;
x1 := oldX1;
x2 := 1;
x3 := oldX4;
x4 := oldX5;
TO: 2;

FROM: 2;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := oldX1 - 1;
assume(2 * oldX2 > 1 && 2 * oldX2 >= 1 + oldX5 && oldX5 > -1 && oldX1 = 1 + oldX5);
x0 := oldX0;
x1 := oldX1 - 1;
x2 := oldX2;
x3 := 2 * oldX2;
x4 := 1 + oldX5;
TO: 1;

FROM: 1;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := oldX1 - 1;
assume(oldX5 < 1 && oldX4 < 3 && oldX5 > -1 && oldX1 = 1 + oldX5);
x0 := oldX0;
x1 := oldX1 - 1;
x2 := oldX2;
x3 := oldX3;
x4 := 1 + oldX5;
TO: 1;

FROM: 2;
oldX0 := x0;
oldX1 := x1;
oldX2 := x2;
oldX3 := x3;
oldX4 := x4;
oldX5 := nondet();
assume(oldX1 > 2 && 2 * oldX2 > 1 && oldX1 > 2 * oldX2 && oldX3 > 3 && oldX0 > 3);
x0 := oldX0;
x1 := oldX1;
x2 := 2 * oldX2;
x3 := oldX3;
x4 := oldX5;
TO: 2;


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

(12) T2 (EQUIVALENT)
Initially, performed program simplifications using lexicographic rank functions:
 * Removed transitions 2, 5, 6, 14, 17, 18 using the following rank functions:
    - Rank function 1:
      RF for loc. 6: 2+3*x1
      RF for loc. 7: 3*x1
      RF for loc. 8: 1+3*x1
      RF for loc. 12: 3*x1
      Bound for (chained) transitions 6: 4
      Bound for (chained) transitions 17: 3
    - Rank function 2:
      RF for loc. 6: x1
      RF for loc. 7: 1+x1-2*x2
      RF for loc. 8: -1+x1
      RF for loc. 12: x1-2*x2
      Bound for (chained) transitions 18: 1
    - Rank function 3:
      RF for loc. 6: 3
      RF for loc. 7: 1
      RF for loc. 8: 2
      RF for loc. 12: 0
      Bound for (chained) transitions 2: 3
      Bound for (chained) transitions 5: 2
      Bound for (chained) transitions 14: 1

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

(13)
YES

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

(14)
Obligation:
SCC
----------------------------------------

(15) 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

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

(16)
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

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

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

(18)
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

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

(19) 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


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

(20)
YES

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

(21)
Obligation:
SCC
----------------------------------------

(22) 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

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

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

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

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

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

(25)
YES