KILLED
proof of input_smUS2xs0Rj.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) CpxTrsToCdtProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CdtProblem
    (7) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxRelTRS
    (9) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxRelTRS
        (11) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
        (12) typed CpxTrs
    (13) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
    (14) TRS for Loop Detection
(15) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(16) CdtProblem
    (17) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (18) CdtProblem
    (19) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (20) CdtProblem
    (21) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (22) CdtProblem
    (23) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (24) CpxRelTRS
        (25) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (26) CpxTRS
        (27) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (28) CpxWeightedTrs
            (29) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
            (30) CpxWeightedTrs
            (31) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (32) CpxTypedWeightedTrs
            (33) CompletionProof [UPPER BOUND(ID), 0 ms]
            (34) CpxTypedWeightedCompleteTrs
                (35) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
                (36) CpxTypedWeightedCompleteTrs
                (37) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (38) CpxRNTS
                (39) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
                (40) CpxRNTS
                (41) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
                (42) CpxRNTS
                (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (44) CpxRNTS
                (45) IntTrsBoundProof [UPPER BOUND(ID), 210 ms]
                (46) CpxRNTS
                (47) IntTrsBoundProof [UPPER BOUND(ID), 76 ms]
                (48) CpxRNTS
                (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (50) CpxRNTS
                (51) IntTrsBoundProof [UPPER BOUND(ID), 122 ms]
                (52) CpxRNTS
                (53) IntTrsBoundProof [UPPER BOUND(ID), 43 ms]
                (54) CpxRNTS
                (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (56) CpxRNTS
                (57) IntTrsBoundProof [UPPER BOUND(ID), 453 ms]
                (58) CpxRNTS
                (59) IntTrsBoundProof [UPPER BOUND(ID), 106 ms]
                (60) CpxRNTS
                (61) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (62) CpxRNTS
                (63) IntTrsBoundProof [UPPER BOUND(ID), 70 ms]
                (64) CpxRNTS
                (65) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
                (66) CpxRNTS
                (67) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (68) CpxRNTS
                (69) IntTrsBoundProof [UPPER BOUND(ID), 122 ms]
                (70) CpxRNTS
                (71) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
                (72) CpxRNTS
                (73) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (74) CpxRNTS
                (75) IntTrsBoundProof [UPPER BOUND(ID), 112 ms]
                (76) CpxRNTS
                (77) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
                (78) CpxRNTS
                (79) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (80) CpxRNTS
                (81) IntTrsBoundProof [UPPER BOUND(ID), 1302 ms]
                (82) CpxRNTS
                (83) IntTrsBoundProof [UPPER BOUND(ID), 146 ms]
                (84) CpxRNTS
                (85) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (86) CpxRNTS
                (87) IntTrsBoundProof [UPPER BOUND(ID), 3740 ms]
                (88) CpxRNTS
                (89) IntTrsBoundProof [UPPER BOUND(ID), 1321 ms]
                (90) CpxRNTS
            (91) CompletionProof [UPPER BOUND(ID), 0 ms]
            (92) CpxTypedWeightedCompleteTrs
                (93) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (94) CpxRNTS
    (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
        (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (98) CdtProblem
        (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (100) CdtProblem
        (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (102) CdtProblem
        (103) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (104) CdtProblem
        (105) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 25 ms]
        (106) CdtProblem
        (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (108) CdtProblem
        (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (110) CdtProblem
        (111) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (112) CdtProblem
        (113) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (114) CdtProblem
        (115) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (116) CdtProblem
        (117) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (118) CdtProblem
        (119) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (120) CdtProblem
        (121) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (122) CdtProblem
        (123) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (124) CdtProblem
        (125) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (126) CdtProblem
        (127) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (128) CdtProblem
        (129) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (130) CdtProblem
        (131) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (132) CdtProblem
        (133) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (134) CdtProblem
        (135) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (136) CdtProblem
        (137) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (138) CdtProblem
        (139) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (140) CdtProblem
        (141) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (142) CdtProblem
        (143) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (144) CdtProblem
        (145) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (146) CdtProblem
        (147) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (148) CdtProblem
        (149) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (150) CdtProblem
        (151) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (152) CdtProblem
        (153) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (154) CdtProblem
        (155) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (156) CdtProblem
        (157) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (158) CdtProblem
(159) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(160) CpxWeightedTrs
    (161) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (162) CpxWeightedTrs
    (163) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CpxTypedWeightedTrs
    (165) CompletionProof [UPPER BOUND(ID), 0 ms]
    (166) CpxTypedWeightedCompleteTrs
        (167) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (168) CpxTypedWeightedCompleteTrs
        (169) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (170) CpxRNTS
        (171) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (172) CpxRNTS
        (173) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (174) CpxRNTS
        (175) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (176) CpxRNTS
        (177) IntTrsBoundProof [UPPER BOUND(ID), 126 ms]
        (178) CpxRNTS
        (179) IntTrsBoundProof [UPPER BOUND(ID), 17 ms]
        (180) CpxRNTS
        (181) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (182) CpxRNTS
        (183) IntTrsBoundProof [UPPER BOUND(ID), 348 ms]
        (184) CpxRNTS
        (185) IntTrsBoundProof [UPPER BOUND(ID), 149 ms]
        (186) CpxRNTS
        (187) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (188) CpxRNTS
        (189) IntTrsBoundProof [UPPER BOUND(ID), 102 ms]
        (190) CpxRNTS
        (191) IntTrsBoundProof [UPPER BOUND(ID), 6 ms]
        (192) CpxRNTS
        (193) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (194) CpxRNTS
        (195) IntTrsBoundProof [UPPER BOUND(ID), 4714 ms]
        (196) CpxRNTS
        (197) IntTrsBoundProof [UPPER BOUND(ID), 2075 ms]
        (198) CpxRNTS
    (199) CompletionProof [UPPER BOUND(ID), 0 ms]
    (200) CpxTypedWeightedCompleteTrs
        (201) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (202) CpxRNTS


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

(0)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024 -> 1024_1(0)
   1024_1(x) -> if(lt(x, 10), x)
   if(true, x) -> double(1024_1(s(x)))
   if(false, x) -> s(0)
   lt(0, s(y)) -> true
   lt(x, 0) -> false
   lt(s(x), s(y)) -> lt(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   10 -> double(s(double(s(s(0)))))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(2)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024' -> 1024_1(0')
   1024_1(x) -> if(lt(x, 10'), x)
   if(true, x) -> double(1024_1(s(x)))
   if(false, x) -> s(0')
   lt(0', s(y)) -> true
   lt(x, 0') -> false
   lt(s(x), s(y)) -> lt(x, y)
   double(0') -> 0'
   double(s(x)) -> s(s(double(x)))
   10' -> double(s(double(s(s(0')))))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(3) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(4)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024 -> 1024_1(0)
   1024_1(x) -> if(lt(x, 10), x)
   if(true, x) -> double(1024_1(s(x)))
   if(false, x) -> s(0)
   lt(0, s(y)) -> true
   lt(x, 0) -> false
   lt(s(x), s(y)) -> lt(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   10 -> double(s(double(s(s(0)))))

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(5) CpxTrsToCdtProof (BOTH BOUNDS(ID, ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   1024 -> 1024_1(0)
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   10 -> double(s(double(s(s(0)))))
Tuples:
   1024' -> c(1024_1'(0))
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0) -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))
S tuples:
   1024' -> c(1024_1'(0))
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0) -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))
K tuples:none
Defined Rule Symbols:   1024, 1024_1_1, if_2, lt_2, double_1, 10

Defined Pair Symbols:   1024', 1024_1'_1, IF_2, LT_2, DOUBLE_1, 10'

Compound Symbols:   c_1, c1_3, c2_2, c3, c4, c5, c6_1, c7, c8_1, c9_2


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

(7) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(8)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024' -> c(1024_1'(0))
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0) -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))

The (relative) TRS S consists of the following rules:

   1024 -> 1024_1(0)
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   10 -> double(s(double(s(s(0)))))

Rewrite Strategy: INNERMOST
----------------------------------------

(9) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(10)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024' -> c(1024_1'(0'))
   1024_1'(z0) -> c1(IF(lt(z0, 10'), z0), LT(z0, 10'), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0', s(z0)) -> c4
   LT(z0, 0') -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0') -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0'))))), DOUBLE(s(s(0'))))

The (relative) TRS S consists of the following rules:

   1024' -> 1024_1(0')
   1024_1(z0) -> if(lt(z0, 10'), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0')
   lt(0', s(z0)) -> true
   lt(z0, 0') -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0') -> 0'
   double(s(z0)) -> s(s(double(z0)))
   10' -> double(s(double(s(s(0')))))

Rewrite Strategy: INNERMOST
----------------------------------------

(11) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Inferred types.
----------------------------------------

(12)
Obligation:
Innermost TRS:
Rules:
1024' -> c(1024_1'(0'))
1024_1'(z0) -> c1(IF(lt(z0, 10'), z0), LT(z0, 10'), 10')
IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
IF(false, z0) -> c3
LT(0', s(z0)) -> c4
LT(z0, 0') -> c5
LT(s(z0), s(z1)) -> c6(LT(z0, z1))
DOUBLE(0') -> c7
DOUBLE(s(z0)) -> c8(DOUBLE(z0))
10' -> c9(DOUBLE(s(double(s(s(0'))))), DOUBLE(s(s(0'))))
1024' -> 1024_1(0')
1024_1(z0) -> if(lt(z0, 10'), z0)
if(true, z0) -> double(1024_1(s(z0)))
if(false, z0) -> s(0')
lt(0', s(z0)) -> true
lt(z0, 0') -> false
lt(s(z0), s(z1)) -> lt(z0, z1)
double(0') -> 0'
double(s(z0)) -> s(s(double(z0)))
10' -> double(s(double(s(s(0')))))

Types:
1024' :: 0':c:s:c9
c :: c1 -> 0':c:s:c9
1024_1' :: 0':c:s:c9 -> c1
0' :: 0':c:s:c9
c1 :: c2:c3 -> c4:c5:c6 -> 0':c:s:c9 -> c1
IF :: true:false -> 0':c:s:c9 -> c2:c3
lt :: 0':c:s:c9 -> 0':c:s:c9 -> true:false
10' :: 0':c:s:c9
LT :: 0':c:s:c9 -> 0':c:s:c9 -> c4:c5:c6
true :: true:false
c2 :: c7:c8 -> c1 -> c2:c3
DOUBLE :: 0':c:s:c9 -> c7:c8
1024_1 :: 0':c:s:c9 -> 0':c:s:c9
s :: 0':c:s:c9 -> 0':c:s:c9
false :: true:false
c3 :: c2:c3
c4 :: c4:c5:c6
c5 :: c4:c5:c6
c6 :: c4:c5:c6 -> c4:c5:c6
c7 :: c7:c8
c8 :: c7:c8 -> c7:c8
c9 :: c7:c8 -> c7:c8 -> 0':c:s:c9
double :: 0':c:s:c9 -> 0':c:s:c9
if :: true:false -> 0':c:s:c9 -> 0':c:s:c9
hole_0':c:s:c91_10 :: 0':c:s:c9
hole_c12_10 :: c1
hole_c2:c33_10 :: c2:c3
hole_c4:c5:c64_10 :: c4:c5:c6
hole_true:false5_10 :: true:false
hole_c7:c86_10 :: c7:c8
gen_0':c:s:c97_10 :: Nat -> 0':c:s:c9
gen_c4:c5:c68_10 :: Nat -> c4:c5:c6
gen_c7:c89_10 :: Nat -> c7:c8

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

(13) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID))
Transformed a relative TRS into a decreasing-loop problem.
----------------------------------------

(14)
Obligation:
Analyzing the following TRS for decreasing loops:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024' -> c(1024_1'(0))
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0) -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))

The (relative) TRS S consists of the following rules:

   1024 -> 1024_1(0)
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   10 -> double(s(double(s(s(0)))))

Rewrite Strategy: INNERMOST
----------------------------------------

(15) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(16)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   1024 -> 1024_1(0)
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   10 -> double(s(double(s(s(0)))))
Tuples:
   1024' -> c(1024_1'(0))
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0) -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))
S tuples:
   1024' -> c(1024_1'(0))
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   IF(false, z0) -> c3
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(0) -> c7
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))
K tuples:none
Defined Rule Symbols:   1024, 1024_1_1, if_2, lt_2, double_1, 10

Defined Pair Symbols:   1024', 1024_1'_1, IF_2, LT_2, DOUBLE_1, 10'

Compound Symbols:   c_1, c1_3, c2_2, c3, c4, c5, c6_1, c7, c8_1, c9_2


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

(17) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   1024' -> c(1024_1'(0))
Removed 4 trailing nodes:
   DOUBLE(0) -> c7
   LT(0, s(z0)) -> c4
   LT(z0, 0) -> c5
   IF(false, z0) -> c3

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

(18)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   1024 -> 1024_1(0)
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   10 -> double(s(double(s(s(0)))))
Tuples:
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))
S tuples:
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c9(DOUBLE(s(double(s(s(0))))), DOUBLE(s(s(0))))
K tuples:none
Defined Rule Symbols:   1024, 1024_1_1, if_2, lt_2, double_1, 10

Defined Pair Symbols:   1024_1'_1, IF_2, LT_2, DOUBLE_1, 10'

Compound Symbols:   c1_3, c2_2, c6_1, c8_1, c9_2


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

(19) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(20)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   1024 -> 1024_1(0)
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   10 -> double(s(double(s(s(0)))))
Tuples:
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
S tuples:
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
K tuples:none
Defined Rule Symbols:   1024, 1024_1_1, if_2, lt_2, double_1, 10

Defined Pair Symbols:   1024_1'_1, IF_2, LT_2, DOUBLE_1, 10'

Compound Symbols:   c1_3, c2_2, c6_1, c8_1, c_1


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

(21) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   1024 -> 1024_1(0)

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

(22)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
S tuples:
   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
K tuples:none
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   1024_1'_1, IF_2, LT_2, DOUBLE_1, 10'

Compound Symbols:   c1_3, c2_2, c6_1, c8_1, c_1


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

(23) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(24)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))

The (relative) TRS S consists of the following rules:

   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)

Rewrite Strategy: INNERMOST
----------------------------------------

(25) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(26)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10')
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(27) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(28)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10') [1]
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0))) [1]
   LT(s(z0), s(z1)) -> c6(LT(z0, z1)) [1]
   DOUBLE(s(z0)) -> c8(DOUBLE(z0)) [1]
   10' -> c(DOUBLE(s(double(s(s(0)))))) [1]
   10' -> c(DOUBLE(s(s(0)))) [1]
   lt(0, s(z0)) -> true [0]
   lt(z0, 0) -> false [0]
   lt(s(z0), s(z1)) -> lt(z0, z1) [0]
   10 -> double(s(double(s(s(0))))) [0]
   double(s(z0)) -> s(s(double(z0))) [0]
   double(0) -> 0 [0]
   1024_1(z0) -> if(lt(z0, 10), z0) [0]
   if(true, z0) -> double(1024_1(s(z0))) [0]
   if(false, z0) -> s(0) [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(29) CpxWeightedTrsRenamingProof (BOTH BOUNDS(ID, ID))
Renamed defined symbols to avoid conflicts with arithmetic symbols:

10 => 10''

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

(30)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10''), z0), LT(z0, 10''), 10') [1]
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0))) [1]
   LT(s(z0), s(z1)) -> c6(LT(z0, z1)) [1]
   DOUBLE(s(z0)) -> c8(DOUBLE(z0)) [1]
   10' -> c(DOUBLE(s(double(s(s(0)))))) [1]
   10' -> c(DOUBLE(s(s(0)))) [1]
   lt(0, s(z0)) -> true [0]
   lt(z0, 0) -> false [0]
   lt(s(z0), s(z1)) -> lt(z0, z1) [0]
   10'' -> double(s(double(s(s(0))))) [0]
   double(s(z0)) -> s(s(double(z0))) [0]
   double(0) -> 0 [0]
   1024_1(z0) -> if(lt(z0, 10''), z0) [0]
   if(true, z0) -> double(1024_1(s(z0))) [0]
   if(false, z0) -> s(0) [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(31) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(32)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10''), z0), LT(z0, 10''), 10') [1]
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0))) [1]
   LT(s(z0), s(z1)) -> c6(LT(z0, z1)) [1]
   DOUBLE(s(z0)) -> c8(DOUBLE(z0)) [1]
   10' -> c(DOUBLE(s(double(s(s(0)))))) [1]
   10' -> c(DOUBLE(s(s(0)))) [1]
   lt(0, s(z0)) -> true [0]
   lt(z0, 0) -> false [0]
   lt(s(z0), s(z1)) -> lt(z0, z1) [0]
   10'' -> double(s(double(s(s(0))))) [0]
   double(s(z0)) -> s(s(double(z0))) [0]
   double(0) -> 0 [0]
   1024_1(z0) -> if(lt(z0, 10''), z0) [0]
   if(true, z0) -> double(1024_1(s(z0))) [0]
   if(false, z0) -> s(0) [0]

The TRS has the following type information:
1024_1' :: s:0 -> c1
c1 :: c2 -> c6 -> c -> c1
IF :: true:false -> s:0 -> c2
lt :: s:0 -> s:0 -> true:false
10'' :: s:0
LT :: s:0 -> s:0 -> c6
10' :: c
true :: true:false
c2 :: c8 -> c1 -> c2
DOUBLE :: s:0 -> c8
1024_1 :: s:0 -> s:0
s :: s:0 -> s:0
c6 :: c6 -> c6
c8 :: c8 -> c8
c :: c8 -> c
double :: s:0 -> s:0
0 :: s:0
false :: true:false
if :: true:false -> s:0 -> s:0

Rewrite Strategy: INNERMOST
----------------------------------------

(33) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   1024_1'_1
   IF_2
   LT_2
   DOUBLE_1
   10'

(c) The following functions are completely defined:

   lt_2
   10''
   double_1
   1024_1_1
   if_2

Due to the following rules being added:

   lt(v0, v1) -> null_lt [0]
   10'' -> 0 [0]
   double(v0) -> 0 [0]
   1024_1(v0) -> 0 [0]
   if(v0, v1) -> 0 [0]

And the following fresh constants:    null_lt, const, const1, const2, const3, const4

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

(34)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10''), z0), LT(z0, 10''), 10') [1]
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0))) [1]
   LT(s(z0), s(z1)) -> c6(LT(z0, z1)) [1]
   DOUBLE(s(z0)) -> c8(DOUBLE(z0)) [1]
   10' -> c(DOUBLE(s(double(s(s(0)))))) [1]
   10' -> c(DOUBLE(s(s(0)))) [1]
   lt(0, s(z0)) -> true [0]
   lt(z0, 0) -> false [0]
   lt(s(z0), s(z1)) -> lt(z0, z1) [0]
   10'' -> double(s(double(s(s(0))))) [0]
   double(s(z0)) -> s(s(double(z0))) [0]
   double(0) -> 0 [0]
   1024_1(z0) -> if(lt(z0, 10''), z0) [0]
   if(true, z0) -> double(1024_1(s(z0))) [0]
   if(false, z0) -> s(0) [0]
   lt(v0, v1) -> null_lt [0]
   10'' -> 0 [0]
   double(v0) -> 0 [0]
   1024_1(v0) -> 0 [0]
   if(v0, v1) -> 0 [0]

The TRS has the following type information:
1024_1' :: s:0 -> c1
c1 :: c2 -> c6 -> c -> c1
IF :: true:false:null_lt -> s:0 -> c2
lt :: s:0 -> s:0 -> true:false:null_lt
10'' :: s:0
LT :: s:0 -> s:0 -> c6
10' :: c
true :: true:false:null_lt
c2 :: c8 -> c1 -> c2
DOUBLE :: s:0 -> c8
1024_1 :: s:0 -> s:0
s :: s:0 -> s:0
c6 :: c6 -> c6
c8 :: c8 -> c8
c :: c8 -> c
double :: s:0 -> s:0
0 :: s:0
false :: true:false:null_lt
if :: true:false:null_lt -> s:0 -> s:0
null_lt :: true:false:null_lt
const :: c1
const1 :: c2
const2 :: c6
const3 :: c
const4 :: c8

Rewrite Strategy: INNERMOST
----------------------------------------

(35) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(36)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, double(s(double(s(s(0)))))), z0), LT(z0, double(s(double(s(s(0)))))), 10') [1]
   1024_1'(z0) -> c1(IF(lt(z0, double(s(double(s(s(0)))))), z0), LT(z0, 0), 10') [1]
   1024_1'(z0) -> c1(IF(lt(z0, 0), z0), LT(z0, double(s(double(s(s(0)))))), 10') [1]
   1024_1'(z0) -> c1(IF(lt(z0, 0), z0), LT(z0, 0), 10') [1]
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), 10''), s(z0))), 1024_1'(s(z0))) [1]
   IF(true, z0) -> c2(DOUBLE(0), 1024_1'(s(z0))) [1]
   LT(s(z0), s(z1)) -> c6(LT(z0, z1)) [1]
   DOUBLE(s(z0)) -> c8(DOUBLE(z0)) [1]
   10' -> c(DOUBLE(s(s(s(double(s(0))))))) [1]
   10' -> c(DOUBLE(s(0))) [1]
   10' -> c(DOUBLE(s(s(0)))) [1]
   lt(0, s(z0)) -> true [0]
   lt(z0, 0) -> false [0]
   lt(s(z0), s(z1)) -> lt(z0, z1) [0]
   10'' -> double(s(s(s(double(s(0)))))) [0]
   10'' -> double(s(0)) [0]
   double(s(z0)) -> s(s(double(z0))) [0]
   double(0) -> 0 [0]
   1024_1(z0) -> if(lt(z0, double(s(double(s(s(0)))))), z0) [0]
   1024_1(z0) -> if(lt(z0, 0), z0) [0]
   if(true, z0) -> double(if(lt(s(z0), 10''), s(z0))) [0]
   if(true, z0) -> double(0) [0]
   if(false, z0) -> s(0) [0]
   lt(v0, v1) -> null_lt [0]
   10'' -> 0 [0]
   double(v0) -> 0 [0]
   1024_1(v0) -> 0 [0]
   if(v0, v1) -> 0 [0]

The TRS has the following type information:
1024_1' :: s:0 -> c1
c1 :: c2 -> c6 -> c -> c1
IF :: true:false:null_lt -> s:0 -> c2
lt :: s:0 -> s:0 -> true:false:null_lt
10'' :: s:0
LT :: s:0 -> s:0 -> c6
10' :: c
true :: true:false:null_lt
c2 :: c8 -> c1 -> c2
DOUBLE :: s:0 -> c8
1024_1 :: s:0 -> s:0
s :: s:0 -> s:0
c6 :: c6 -> c6
c8 :: c8 -> c8
c :: c8 -> c
double :: s:0 -> s:0
0 :: s:0
false :: true:false:null_lt
if :: true:false:null_lt -> s:0 -> s:0
null_lt :: true:false:null_lt
const :: c1
const1 :: c2
const2 :: c6
const3 :: c
const4 :: c8

Rewrite Strategy: INNERMOST
----------------------------------------

(37) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   true => 2
   0 => 0
   false => 1
   null_lt => 0
   const => 0
   const1 => 0
   const2 => 0
   const3 => 0
   const4 => 0

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

(38)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z0, double(1 + double(1 + (1 + 0)))), z0) :|: z = z0, z0 >= 0
   1024_1(z) -{ 0 }-> if(lt(z0, 0), z0) :|: z = z0, z0 >= 0
   1024_1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z0, double(1 + double(1 + (1 + 0)))), z0) + LT(z0, double(1 + double(1 + (1 + 0)))) + 10' :|: z = z0, z0 >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z0, double(1 + double(1 + (1 + 0)))), z0) + LT(z0, 0) + 10' :|: z = z0, z0 >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z0, 0), z0) + LT(z0, double(1 + double(1 + (1 + 0)))) + 10' :|: z = z0, z0 >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z0, 0), z0) + LT(z0, 0) + 10' :|: z = z0, z0 >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z0) :|: z = 1 + z0, z0 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z0, 10''), 1 + z0)) + 1024_1'(1 + z0) :|: z = 2, z0 >= 0, z' = z0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z0) :|: z = 2, z0 >= 0, z' = z0
   LT(z, z') -{ 1 }-> 1 + LT(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   double(z) -{ 0 }-> 1 + (1 + double(z0)) :|: z = 1 + z0, z0 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z0, 10''), 1 + z0)) :|: z = 2, z0 >= 0, z' = z0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z0 >= 0, z' = z0
   if(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z0 >= 0, z' = z0
   lt(z, z') -{ 0 }-> lt(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   lt(z, z') -{ 0 }-> 2 :|: z0 >= 0, z' = 1 + z0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1


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

(39) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(40)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, 0) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, 0) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ 1 }-> 1 + LT(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0


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

(41) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { LT }
   { double }
   { lt }
   { DOUBLE }
   { 10'' }
   { 10' }
   { if }
   { 1024_1', IF }
   { 1024_1 }

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

(42)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, 0) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, 0) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ 1 }-> 1 + LT(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {LT}, {double}, {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}

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

(43) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(44)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, 0) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, 0) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ 1 }-> 1 + LT(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {LT}, {double}, {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: LT
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

(46)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, 0) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, 0) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ 1 }-> 1 + LT(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {LT}, {double}, {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: ?, size: O(1) [0]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: LT
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z'

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

(48)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, 0) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, 0) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ 1 }-> 1 + LT(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {double}, {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]

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

(49) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(50)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + s + 10' :|: s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + s' + 10' :|: s' >= 0, s' <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {double}, {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: double
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2*z

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

(52)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + s + 10' :|: s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + s' + 10' :|: s' >= 0, s' <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {double}, {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: ?, size: O(n^1) [2*z]

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: double
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

(54)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> double(1 + 0) :|: 
   10'' -{ 0 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + s + 10' :|: s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, double(1 + double(1 + (1 + 0)))), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + s' + 10' :|: s' >= 0, s' <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + LT(z, double(1 + double(1 + (1 + 0)))) + 10' :|: z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(0) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]

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

(55) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(56)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + s11))) :|: s11 >= 0, s11 <= 2 * (1 + 0)
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, s17), z) :|: s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(lt(z, s2), z) + s5 + 10' :|: s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, s7), z) + s + 10' :|: s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + s' + 10' :|: s' >= 0, s' <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(lt(z, 0), z) + s10 + 10' :|: s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: lt
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 2

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

(58)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + s11))) :|: s11 >= 0, s11 <= 2 * (1 + 0)
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, s17), z) :|: s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(lt(z, s2), z) + s5 + 10' :|: s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, s7), z) + s + 10' :|: s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + s' + 10' :|: s' >= 0, s' <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(lt(z, 0), z) + s10 + 10' :|: s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {lt}, {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: ?, size: O(1) [2]

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: lt
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

(60)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + s11))) :|: s11 >= 0, s11 <= 2 * (1 + 0)
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z, s17), z) :|: s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(lt(z, 0), z) :|: z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(lt(z, s2), z) + s5 + 10' :|: s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, s7), z) + s + 10' :|: s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z, 0), z) + s' + 10' :|: s' >= 0, s' <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(lt(z, 0), z) + s10 + 10' :|: s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]

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

(61) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(62)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + s11))) :|: s11 >= 0, s11 <= 2 * (1 + 0)
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: DOUBLE
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

(64)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + s11))) :|: s11 >= 0, s11 <= 2 * (1 + 0)
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {DOUBLE}, {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: ?, size: O(1) [0]

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

(65) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: DOUBLE
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

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

(66)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + 0) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + (1 + s11))) :|: s11 >= 0, s11 <= 2 * (1 + 0)
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z - 1) :|: z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(0) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]

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

(67) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(68)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: 10''
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 10

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

(70)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {10''}, {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: ?, size: O(1) [10]

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

(71) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: 10''
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

(72)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(lt(1 + z', 10''), 1 + z')) + 1024_1'(1 + z') :|: z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(lt(1 + z', 10''), 1 + z')) :|: z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]

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

(73) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(74)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(s32, 1 + z')) + 1024_1'(1 + z') :|: s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(s34, 1 + z')) :|: s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: 10'
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

(76)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(s32, 1 + z')) + 1024_1'(1 + z') :|: s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(s34, 1 + z')) :|: s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {10'}, {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: ?, size: O(1) [1]

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

(77) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: 10'
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 6

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

(78)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 1 + s4 }-> 1 + IF(s19, z) + s5 + 10' :|: s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s20, z) + s + 10' :|: s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 1 + s9 }-> 1 + IF(s21, z) + s10 + 10' :|: s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 1 }-> 1 + IF(s22, z) + s' + 10' :|: s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(s32, 1 + z')) + 1024_1'(1 + z') :|: s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(s34, 1 + z')) :|: s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]

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

(79) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(80)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 7 + s4 }-> 1 + IF(s19, z) + s5 + s35 :|: s35 >= 0, s35 <= 1, s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s20, z) + s + s36 :|: s36 >= 0, s36 <= 1, s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 7 + s9 }-> 1 + IF(s21, z) + s10 + s37 :|: s37 >= 0, s37 <= 1, s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s22, z) + s' + s38 :|: s38 >= 0, s38 <= 1, s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(s32, 1 + z')) + 1024_1'(1 + z') :|: s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(s34, 1 + z')) :|: s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: if
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

(82)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 7 + s4 }-> 1 + IF(s19, z) + s5 + s35 :|: s35 >= 0, s35 <= 1, s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s20, z) + s + s36 :|: s36 >= 0, s36 <= 1, s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 7 + s9 }-> 1 + IF(s21, z) + s10 + s37 :|: s37 >= 0, s37 <= 1, s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s22, z) + s' + s38 :|: s38 >= 0, s38 <= 1, s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(s32, 1 + z')) + 1024_1'(1 + z') :|: s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(s34, 1 + z')) :|: s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {if}, {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]
  if: runtime: ?, size: INF

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

(83) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: if
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

(84)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(s24, z) :|: s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> if(s25, z) :|: s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 7 + s4 }-> 1 + IF(s19, z) + s5 + s35 :|: s35 >= 0, s35 <= 1, s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s20, z) + s + s36 :|: s36 >= 0, s36 <= 1, s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 7 + s9 }-> 1 + IF(s21, z) + s10 + s37 :|: s37 >= 0, s37 <= 1, s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s22, z) + s' + s38 :|: s38 >= 0, s38 <= 1, s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 }-> 1 + DOUBLE(if(s32, 1 + z')) + 1024_1'(1 + z') :|: s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> double(if(s34, 1 + z')) :|: s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]
  if: runtime: O(1) [0], size: INF

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

(85) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(86)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> s41 :|: s41 >= 0, s41 <= inf', s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> s42 :|: s42 >= 0, s42 <= inf'', s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 7 + s4 }-> 1 + IF(s19, z) + s5 + s35 :|: s35 >= 0, s35 <= 1, s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s20, z) + s + s36 :|: s36 >= 0, s36 <= 1, s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 7 + s9 }-> 1 + IF(s21, z) + s10 + s37 :|: s37 >= 0, s37 <= 1, s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s22, z) + s' + s38 :|: s38 >= 0, s38 <= 1, s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 + s39 }-> 1 + s40 + 1024_1'(1 + z') :|: s39 >= 0, s39 <= inf, s40 >= 0, s40 <= 0, s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> s44 :|: s43 >= 0, s43 <= inf1, s44 >= 0, s44 <= 2 * s43, s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]
  if: runtime: O(1) [0], size: INF

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

(87) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: 1024_1'
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

Computed SIZE bound using CoFloCo for: IF
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

(88)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> s41 :|: s41 >= 0, s41 <= inf', s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> s42 :|: s42 >= 0, s42 <= inf'', s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 7 + s4 }-> 1 + IF(s19, z) + s5 + s35 :|: s35 >= 0, s35 <= 1, s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s20, z) + s + s36 :|: s36 >= 0, s36 <= 1, s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 7 + s9 }-> 1 + IF(s21, z) + s10 + s37 :|: s37 >= 0, s37 <= 1, s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s22, z) + s' + s38 :|: s38 >= 0, s38 <= 1, s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 + s39 }-> 1 + s40 + 1024_1'(1 + z') :|: s39 >= 0, s39 <= inf, s40 >= 0, s40 <= 0, s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> s44 :|: s43 >= 0, s43 <= inf1, s44 >= 0, s44 <= 2 * s43, s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]
  if: runtime: O(1) [0], size: INF
  1024_1': runtime: ?, size: O(1) [0]
  IF: runtime: ?, size: O(1) [1]

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

(89) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: 1024_1'
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

(90)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 4 + s11 }-> 1 + s28 :|: s28 >= 0, s28 <= 0, s11 >= 0, s11 <= 2 * (1 + 0)
   10' -{ 2 }-> 1 + s29 :|: s29 >= 0, s29 <= 0
   10' -{ 3 }-> 1 + s30 :|: s30 >= 0, s30 <= 0
   10'' -{ 0 }-> s13 :|: s12 >= 0, s12 <= 2 * (1 + 0), s13 >= 0, s13 <= 2 * (1 + (1 + (1 + s12)))
   10'' -{ 0 }-> s14 :|: s14 >= 0, s14 <= 2 * (1 + 0)
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> s41 :|: s41 >= 0, s41 <= inf', s24 >= 0, s24 <= 2, s16 >= 0, s16 <= 2 * (1 + (1 + 0)), s17 >= 0, s17 <= 2 * (1 + s16), z >= 0
   1024_1(z) -{ 0 }-> s42 :|: s42 >= 0, s42 <= inf'', s25 >= 0, s25 <= 2, z >= 0
   1024_1(z) -{ 0 }-> 0 :|: z >= 0
   1024_1'(z) -{ 7 + s4 }-> 1 + IF(s19, z) + s5 + s35 :|: s35 >= 0, s35 <= 1, s19 >= 0, s19 <= 2, s1 >= 0, s1 <= 2 * (1 + (1 + 0)), s2 >= 0, s2 <= 2 * (1 + s1), s3 >= 0, s3 <= 2 * (1 + (1 + 0)), s4 >= 0, s4 <= 2 * (1 + s3), s5 >= 0, s5 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s20, z) + s + s36 :|: s36 >= 0, s36 <= 1, s20 >= 0, s20 <= 2, s6 >= 0, s6 <= 2 * (1 + (1 + 0)), s7 >= 0, s7 <= 2 * (1 + s6), s >= 0, s <= 0, z >= 0
   1024_1'(z) -{ 7 + s9 }-> 1 + IF(s21, z) + s10 + s37 :|: s37 >= 0, s37 <= 1, s21 >= 0, s21 <= 2, s8 >= 0, s8 <= 2 * (1 + (1 + 0)), s9 >= 0, s9 <= 2 * (1 + s8), s10 >= 0, s10 <= 0, z >= 0
   1024_1'(z) -{ 7 }-> 1 + IF(s22, z) + s' + s38 :|: s38 >= 0, s38 <= 1, s22 >= 0, s22 <= 2, s' >= 0, s' <= 0, z >= 0
   DOUBLE(z) -{ z }-> 1 + s27 :|: s27 >= 0, s27 <= 0, z - 1 >= 0
   IF(z, z') -{ 1 }-> 1 + s26 + 1024_1'(1 + z') :|: s26 >= 0, s26 <= 0, z = 2, z' >= 0
   IF(z, z') -{ 1 + s39 }-> 1 + s40 + 1024_1'(1 + z') :|: s39 >= 0, s39 <= inf, s40 >= 0, s40 <= 0, s31 >= 0, s31 <= 10, s32 >= 0, s32 <= 2, z = 2, z' >= 0
   LT(z, z') -{ z' }-> 1 + s'' :|: s'' >= 0, s'' <= 0, z' - 1 >= 0, z - 1 >= 0
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: z >= 0
   double(z) -{ 0 }-> 1 + (1 + s15) :|: s15 >= 0, s15 <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 0 }-> s18 :|: s18 >= 0, s18 <= 2 * 0, z = 2, z' >= 0
   if(z, z') -{ 0 }-> s44 :|: s43 >= 0, s43 <= inf1, s44 >= 0, s44 <= 2 * s43, s33 >= 0, s33 <= 10, s34 >= 0, s34 <= 2, z = 2, z' >= 0
   if(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z' >= 0
   lt(z, z') -{ 0 }-> s23 :|: s23 >= 0, s23 <= 2, z' - 1 >= 0, z - 1 >= 0
   lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {1024_1',IF}, {1024_1}
Previous analysis results are:
  LT: runtime: O(n^1) [z'], size: O(1) [0]
  double: runtime: O(1) [0], size: O(n^1) [2*z]
  lt: runtime: O(1) [0], size: O(1) [2]
  DOUBLE: runtime: O(n^1) [z], size: O(1) [0]
  10'': runtime: O(1) [0], size: O(1) [10]
  10': runtime: O(1) [6], size: O(1) [1]
  if: runtime: O(1) [0], size: INF
  1024_1': runtime: INF, size: O(1) [0]
  IF: runtime: ?, size: O(1) [1]

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

(91) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   lt(v0, v1) -> null_lt [0]
   10'' -> null_10'' [0]
   double(v0) -> null_double [0]
   1024_1(v0) -> null_1024_1 [0]
   if(v0, v1) -> null_if [0]
   IF(v0, v1) -> null_IF [0]
   LT(v0, v1) -> null_LT [0]
   DOUBLE(v0) -> null_DOUBLE [0]

And the following fresh constants:    null_lt, null_10'', null_double, null_1024_1, null_if, null_IF, null_LT, null_DOUBLE, const, const1

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

(92)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024_1'(z0) -> c1(IF(lt(z0, 10''), z0), LT(z0, 10''), 10') [1]
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0))) [1]
   LT(s(z0), s(z1)) -> c6(LT(z0, z1)) [1]
   DOUBLE(s(z0)) -> c8(DOUBLE(z0)) [1]
   10' -> c(DOUBLE(s(double(s(s(0)))))) [1]
   10' -> c(DOUBLE(s(s(0)))) [1]
   lt(0, s(z0)) -> true [0]
   lt(z0, 0) -> false [0]
   lt(s(z0), s(z1)) -> lt(z0, z1) [0]
   10'' -> double(s(double(s(s(0))))) [0]
   double(s(z0)) -> s(s(double(z0))) [0]
   double(0) -> 0 [0]
   1024_1(z0) -> if(lt(z0, 10''), z0) [0]
   if(true, z0) -> double(1024_1(s(z0))) [0]
   if(false, z0) -> s(0) [0]
   lt(v0, v1) -> null_lt [0]
   10'' -> null_10'' [0]
   double(v0) -> null_double [0]
   1024_1(v0) -> null_1024_1 [0]
   if(v0, v1) -> null_if [0]
   IF(v0, v1) -> null_IF [0]
   LT(v0, v1) -> null_LT [0]
   DOUBLE(v0) -> null_DOUBLE [0]

The TRS has the following type information:
1024_1' :: s:0:null_10'':null_double:null_1024_1:null_if -> c1
c1 :: c2:null_IF -> c6:null_LT -> c -> c1
IF :: true:false:null_lt -> s:0:null_10'':null_double:null_1024_1:null_if -> c2:null_IF
lt :: s:0:null_10'':null_double:null_1024_1:null_if -> s:0:null_10'':null_double:null_1024_1:null_if -> true:false:null_lt
10'' :: s:0:null_10'':null_double:null_1024_1:null_if
LT :: s:0:null_10'':null_double:null_1024_1:null_if -> s:0:null_10'':null_double:null_1024_1:null_if -> c6:null_LT
10' :: c
true :: true:false:null_lt
c2 :: c8:null_DOUBLE -> c1 -> c2:null_IF
DOUBLE :: s:0:null_10'':null_double:null_1024_1:null_if -> c8:null_DOUBLE
1024_1 :: s:0:null_10'':null_double:null_1024_1:null_if -> s:0:null_10'':null_double:null_1024_1:null_if
s :: s:0:null_10'':null_double:null_1024_1:null_if -> s:0:null_10'':null_double:null_1024_1:null_if
c6 :: c6:null_LT -> c6:null_LT
c8 :: c8:null_DOUBLE -> c8:null_DOUBLE
c :: c8:null_DOUBLE -> c
double :: s:0:null_10'':null_double:null_1024_1:null_if -> s:0:null_10'':null_double:null_1024_1:null_if
0 :: s:0:null_10'':null_double:null_1024_1:null_if
false :: true:false:null_lt
if :: true:false:null_lt -> s:0:null_10'':null_double:null_1024_1:null_if -> s:0:null_10'':null_double:null_1024_1:null_if
null_lt :: true:false:null_lt
null_10'' :: s:0:null_10'':null_double:null_1024_1:null_if
null_double :: s:0:null_10'':null_double:null_1024_1:null_if
null_1024_1 :: s:0:null_10'':null_double:null_1024_1:null_if
null_if :: s:0:null_10'':null_double:null_1024_1:null_if
null_IF :: c2:null_IF
null_LT :: c6:null_LT
null_DOUBLE :: c8:null_DOUBLE
const :: c1
const1 :: c

Rewrite Strategy: INNERMOST
----------------------------------------

(93) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   true => 2
   0 => 0
   false => 1
   null_lt => 0
   null_10'' => 0
   null_double => 0
   null_1024_1 => 0
   null_if => 0
   null_IF => 0
   null_LT => 0
   null_DOUBLE => 0
   const => 0
   const1 => 0

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

(94)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> 1 + DOUBLE(1 + double(1 + (1 + 0))) :|: 
   10' -{ 1 }-> 1 + DOUBLE(1 + (1 + 0)) :|: 
   10'' -{ 0 }-> double(1 + double(1 + (1 + 0))) :|: 
   10'' -{ 0 }-> 0 :|: 
   1024_1(z) -{ 0 }-> if(lt(z0, 10''), z0) :|: z = z0, z0 >= 0
   1024_1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   1024_1'(z) -{ 1 }-> 1 + IF(lt(z0, 10''), z0) + LT(z0, 10'') + 10' :|: z = z0, z0 >= 0
   DOUBLE(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   DOUBLE(z) -{ 1 }-> 1 + DOUBLE(z0) :|: z = 1 + z0, z0 >= 0
   IF(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   IF(z, z') -{ 1 }-> 1 + DOUBLE(1024_1(1 + z0)) + 1024_1'(1 + z0) :|: z = 2, z0 >= 0, z' = z0
   LT(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   LT(z, z') -{ 1 }-> 1 + LT(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   double(z) -{ 0 }-> 0 :|: z = 0
   double(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   double(z) -{ 0 }-> 1 + (1 + double(z0)) :|: z = 1 + z0, z0 >= 0
   if(z, z') -{ 0 }-> double(1024_1(1 + z0)) :|: z = 2, z0 >= 0, z' = z0
   if(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   if(z, z') -{ 0 }-> 1 + 0 :|: z = 1, z0 >= 0, z' = z0
   lt(z, z') -{ 0 }-> lt(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   lt(z, z') -{ 0 }-> 2 :|: z0 >= 0, z' = 1 + z0, z = 0
   lt(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1

Only complete derivations are relevant for the runtime complexity.

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

(95) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace 1024_1'(z0) -> c1(IF(lt(z0, 10), z0), LT(z0, 10), 10') by 
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')
S tuples:
   IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0)))
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')
K tuples:none
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   IF_2, LT_2, DOUBLE_1, 10', 1024_1'_1

Compound Symbols:   c2_2, c6_1, c8_1, c_1, c1_3


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

(97) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(true, z0) -> c2(DOUBLE(1024_1(s(z0))), 1024_1'(s(z0))) by 
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(double(s(s(0))))))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
K tuples:none
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c2_2


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

(99) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace 10' -> c(DOUBLE(s(double(s(s(0)))))) by 
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
K tuples:none
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c2_2


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

(101) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace 1024_1'(x0) -> c1(IF(lt(x0, double(s(double(s(s(0)))))), x0), LT(x0, 10), 10') by 
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(LT(x0, 10), 10')

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(LT(x0, 10), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(LT(x0, 10), 10')
K tuples:none
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', IF_2, 1024_1'_1

Compound Symbols:   c6_1, c8_1, c_1, c2_2, c1_3, c1_2


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

(103) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
K tuples:none
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', IF_2, 1024_1'_1

Compound Symbols:   c6_1, c8_1, c_1, c2_2, c1_3, c3_1


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

(105) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
We considered the (Usable) Rules:none
And the Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(10) = 0
   POL(10') = 0
   POL(1024_1(x_1)) = [1] + x_1
   POL(1024_1'(x_1)) = [1]
   POL(DOUBLE(x_1)) = 0
   POL(IF(x_1, x_2)) = [1]
   POL(LT(x_1, x_2)) = 0
   POL(c(x_1)) = x_1
   POL(c1(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c2(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(double(x_1)) = 0
   POL(false) = [1]
   POL(if(x_1, x_2)) = [1] + x_2
   POL(lt(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', IF_2, 1024_1'_1

Compound Symbols:   c6_1, c8_1, c_1, c2_2, c1_3, c3_1


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

(107) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), 10), s(x0))), 1024_1'(s(x0))) by 
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(double(s(0)))))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(109) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace 10' -> c(DOUBLE(s(s(s(double(s(0))))))) by 
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(111) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 1024_1'(x0) -> c1(IF(lt(x0, s(s(double(double(s(s(0))))))), x0), LT(x0, 10), 10') by 1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(113) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(x0) -> c1(IF(lt(x0, double(s(s(s(double(s(0))))))), x0), LT(x0, 10), 10') by 
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c2_2, c1_3


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

(115) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 1024_1'(x0) -> c3(LT(x0, 10)) by 1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0)))))))
----------------------------------------

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(x0) -> c3(10')
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0)))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(x0) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c2_2, c1_3


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

(117) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(x0) -> c3(10') by 
   1024_1'(s(x0)) -> c3(10')

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0)))))))
   1024_1'(s(x0)) -> c3(10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0)))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', IF_2, 1024_1'_1

Compound Symbols:   c6_1, c8_1, c_1, c2_2, c1_3, c3_1


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

(119) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace IF(true, x0) -> c2(DOUBLE(if(lt(s(x0), double(s(double(s(s(0)))))), s(x0))), 1024_1'(s(x0))) by IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0)))))))
   1024_1'(s(x0)) -> c3(10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(double(0))))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(121) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 10' -> c(DOUBLE(s(s(s(s(s(double(0)))))))) by 10' -> c(DOUBLE(s(s(s(s(s(0)))))))
----------------------------------------

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0)))))))
   1024_1'(s(x0)) -> c3(10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10')
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(123) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, double(s(double(s(s(0)))))), 10') by 1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
----------------------------------------

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0)))))))
   1024_1'(s(x0)) -> c3(10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(125) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(z0) -> c3(LT(z0, double(s(double(s(s(0))))))) by 
   1024_1'(s(x0)) -> c3(LT(s(x0), double(s(double(s(s(0)))))))

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   1024_1'(s(x0)) -> c3(10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(x0)) -> c3(LT(s(x0), double(s(double(s(s(0)))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c3_1, c2_2


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

(127) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 1024_1'(s(x0)) -> c1(IF(lt(s(x0), double(s(s(s(double(s(0))))))), s(x0)), LT(s(x0), 10), 10') by 1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
----------------------------------------

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c3(10')
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(x0)) -> c3(LT(s(x0), double(s(double(s(s(0)))))))
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0)))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c2_2, c1_3


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

(129) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace IF(true, z0) -> c2(DOUBLE(if(lt(s(z0), s(s(double(double(s(s(0))))))), s(z0))), 1024_1'(s(z0))) by IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
----------------------------------------

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c3(10')
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(x0)) -> c3(LT(s(x0), double(s(double(s(s(0)))))))
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c1_3, c2_2


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

(131) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 1024_1'(s(x0)) -> c3(LT(s(x0), double(s(double(s(s(0))))))) by 1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0))))))))
----------------------------------------

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c3(10')
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
   1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0))))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c1_3, c2_2


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

(133) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(z0) -> c1(IF(lt(z0, s(s(double(double(s(s(0))))))), z0), LT(z0, s(s(double(double(s(s(0))))))), 10') by 
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c3(10')
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
   1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0))))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10')
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c1_3, c2_2


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

(135) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace 1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), double(s(double(s(s(0)))))), 10') by 1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
----------------------------------------

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c3(10')
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
   1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0))))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0)))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c2_2, c1_3


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

(137) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace IF(true, z0) -> c2(DOUBLE(if(lt(z0, s(double(double(s(s(0)))))), s(z0))), 1024_1'(s(z0))) by 
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   1024_1'(s(x0)) -> c3(10')
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0))))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(x0)) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c1_3, c2_2


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

(139) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(s(x0)) -> c3(10') by 
   1024_1'(s(s(x0))) -> c3(10')

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0))))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
   1024_1'(s(s(x0))) -> c3(10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c1_3, c2_2


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

(141) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(s(z0)) -> c3(LT(s(z0), s(s(double(double(s(s(0)))))))) by 
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c2_2, c3_1


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

(143) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(s(x0)) -> c1(IF(lt(s(x0), s(s(double(double(s(s(0))))))), s(x0)), LT(s(x0), s(s(double(double(s(s(0))))))), 10') by 
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c1_3, c2_2, c3_1


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

(145) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace 1024_1'(s(z0)) -> c1(IF(lt(s(z0), double(s(s(s(double(s(0))))))), s(z0)), LT(s(z0), s(s(double(double(s(s(0))))))), 10') by 
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', IF_2, 1024_1'_1

Compound Symbols:   c6_1, c8_1, c_1, c2_2, c3_1, c1_3


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

(147) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace IF(true, s(x0)) -> c2(DOUBLE(if(lt(s(x0), s(double(double(s(s(0)))))), s(s(x0)))), 1024_1'(s(s(x0)))) by 
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
S tuples:
   LT(s(z0), s(z1)) -> c6(LT(z0, z1))
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   LT_2, DOUBLE_1, 10', 1024_1'_1, IF_2

Compound Symbols:   c6_1, c8_1, c_1, c3_1, c1_3, c2_2


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

(149) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LT(s(z0), s(z1)) -> c6(LT(z0, z1)) by 
   LT(s(s(y0)), s(s(y1))) -> c6(LT(s(y0), s(y1)))

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(y0)), s(s(y1))) -> c6(LT(s(y0), s(y1)))
S tuples:
   DOUBLE(s(z0)) -> c8(DOUBLE(z0))
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(y0)), s(s(y1))) -> c6(LT(s(y0), s(y1)))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   DOUBLE_1, 10', 1024_1'_1, IF_2, LT_2

Compound Symbols:   c8_1, c_1, c3_1, c1_3, c2_2, c6_1


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

(151) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DOUBLE(s(z0)) -> c8(DOUBLE(z0)) by 
   DOUBLE(s(s(y0))) -> c8(DOUBLE(s(y0)))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(y0)), s(s(y1))) -> c6(LT(s(y0), s(y1)))
   DOUBLE(s(s(y0))) -> c8(DOUBLE(s(y0)))
S tuples:
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(y0)), s(s(y1))) -> c6(LT(s(y0), s(y1)))
   DOUBLE(s(s(y0))) -> c8(DOUBLE(s(y0)))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   10', 1024_1'_1, IF_2, LT_2, DOUBLE_1

Compound Symbols:   c_1, c3_1, c1_3, c2_2, c6_1, c8_1


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

(153) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LT(s(s(y0)), s(s(y1))) -> c6(LT(s(y0), s(y1))) by 
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   DOUBLE(s(s(y0))) -> c8(DOUBLE(s(y0)))
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))
S tuples:
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   DOUBLE(s(s(y0))) -> c8(DOUBLE(s(y0)))
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   10', 1024_1'_1, IF_2, DOUBLE_1, LT_2

Compound Symbols:   c_1, c3_1, c1_3, c2_2, c8_1, c6_1


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

(155) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace DOUBLE(s(s(y0))) -> c8(DOUBLE(s(y0))) by 
   DOUBLE(s(s(s(y0)))) -> c8(DOUBLE(s(s(y0))))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))
   DOUBLE(s(s(s(y0)))) -> c8(DOUBLE(s(s(y0))))
S tuples:
   10' -> c(DOUBLE(s(s(0))))
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))
   DOUBLE(s(s(s(y0)))) -> c8(DOUBLE(s(s(y0))))
K tuples:
   1024_1'(x0) -> c3(LT(x0, 10))
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   10', 1024_1'_1, IF_2, LT_2, DOUBLE_1

Compound Symbols:   c_1, c3_1, c1_3, c2_2, c6_1, c8_1


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

(157) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   10' -> c(DOUBLE(s(s(0))))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt(0, s(z0)) -> true
   lt(z0, 0) -> false
   lt(s(z0), s(z1)) -> lt(z0, z1)
   10 -> double(s(double(s(s(0)))))
   double(s(z0)) -> s(s(double(z0)))
   double(0) -> 0
   1024_1(z0) -> if(lt(z0, 10), z0)
   if(true, z0) -> double(1024_1(s(z0)))
   if(false, z0) -> s(0)
Tuples:
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c3(10')
   1024_1'(s(s(x0))) -> c3(LT(s(s(x0)), s(s(double(double(s(s(0))))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))
   DOUBLE(s(s(s(y0)))) -> c8(DOUBLE(s(s(y0))))
S tuples:
   10' -> c(DOUBLE(s(s(s(s(s(0)))))))
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), s(s(double(double(s(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   1024_1'(s(s(x0))) -> c1(IF(lt(s(s(x0)), double(s(s(s(double(s(0))))))), s(s(x0))), LT(s(s(x0)), s(s(double(double(s(s(0))))))), 10')
   IF(true, s(s(x0))) -> c2(DOUBLE(if(lt(s(s(x0)), s(double(double(s(s(0)))))), s(s(s(x0))))), 1024_1'(s(s(s(x0)))))
   LT(s(s(s(y0))), s(s(s(y1)))) -> c6(LT(s(s(y0)), s(s(y1))))
   DOUBLE(s(s(s(y0)))) -> c8(DOUBLE(s(s(y0))))
K tuples:
   1024_1'(s(s(x0))) -> c3(10')
Defined Rule Symbols:   lt_2, 10, double_1, 1024_1_1, if_2

Defined Pair Symbols:   10', 1024_1'_1, IF_2, LT_2, DOUBLE_1

Compound Symbols:   c_1, c3_1, c1_3, c2_2, c6_1, c8_1


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

(159) RelTrsToWeightedTrsProof (UPPER BOUND(ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(160)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024 -> 1024_1(0) [1]
   1024_1(x) -> if(lt(x, 10), x) [1]
   if(true, x) -> double(1024_1(s(x))) [1]
   if(false, x) -> s(0) [1]
   lt(0, s(y)) -> true [1]
   lt(x, 0) -> false [1]
   lt(s(x), s(y)) -> lt(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   10 -> double(s(double(s(s(0))))) [1]

Rewrite Strategy: INNERMOST
----------------------------------------

(161) CpxWeightedTrsRenamingProof (BOTH BOUNDS(ID, ID))
Renamed defined symbols to avoid conflicts with arithmetic symbols:

1024 => 1024'
10 => 10'

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

(162)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   1024' -> 1024_1(0) [1]
   1024_1(x) -> if(lt(x, 10'), x) [1]
   if(true, x) -> double(1024_1(s(x))) [1]
   if(false, x) -> s(0) [1]
   lt(0, s(y)) -> true [1]
   lt(x, 0) -> false [1]
   lt(s(x), s(y)) -> lt(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   10' -> double(s(double(s(s(0))))) [1]

Rewrite Strategy: INNERMOST
----------------------------------------

(163) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(164)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024' -> 1024_1(0) [1]
   1024_1(x) -> if(lt(x, 10'), x) [1]
   if(true, x) -> double(1024_1(s(x))) [1]
   if(false, x) -> s(0) [1]
   lt(0, s(y)) -> true [1]
   lt(x, 0) -> false [1]
   lt(s(x), s(y)) -> lt(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   10' -> double(s(double(s(s(0))))) [1]

The TRS has the following type information:
1024' :: 0:s
1024_1 :: 0:s -> 0:s
0 :: 0:s
if :: true:false -> 0:s -> 0:s
lt :: 0:s -> 0:s -> true:false
10' :: 0:s
true :: true:false
double :: 0:s -> 0:s
s :: 0:s -> 0:s
false :: true:false

Rewrite Strategy: INNERMOST
----------------------------------------

(165) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   1024'

(c) The following functions are completely defined:

   lt_2
   10'
   double_1
   1024_1_1
   if_2

Due to the following rules being added:
none

And the following fresh constants: none

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

(166)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024' -> 1024_1(0) [1]
   1024_1(x) -> if(lt(x, 10'), x) [1]
   if(true, x) -> double(1024_1(s(x))) [1]
   if(false, x) -> s(0) [1]
   lt(0, s(y)) -> true [1]
   lt(x, 0) -> false [1]
   lt(s(x), s(y)) -> lt(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   10' -> double(s(double(s(s(0))))) [1]

The TRS has the following type information:
1024' :: 0:s
1024_1 :: 0:s -> 0:s
0 :: 0:s
if :: true:false -> 0:s -> 0:s
lt :: 0:s -> 0:s -> true:false
10' :: 0:s
true :: true:false
double :: 0:s -> 0:s
s :: 0:s -> 0:s
false :: true:false

Rewrite Strategy: INNERMOST
----------------------------------------

(167) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(168)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024' -> 1024_1(0) [1]
   1024_1(x) -> if(lt(x, double(s(double(s(s(0)))))), x) [2]
   if(true, x) -> double(if(lt(s(x), 10'), s(x))) [2]
   if(false, x) -> s(0) [1]
   lt(0, s(y)) -> true [1]
   lt(x, 0) -> false [1]
   lt(s(x), s(y)) -> lt(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   10' -> double(s(s(s(double(s(0)))))) [2]

The TRS has the following type information:
1024' :: 0:s
1024_1 :: 0:s -> 0:s
0 :: 0:s
if :: true:false -> 0:s -> 0:s
lt :: 0:s -> 0:s -> true:false
10' :: 0:s
true :: true:false
double :: 0:s -> 0:s
s :: 0:s -> 0:s
false :: true:false

Rewrite Strategy: INNERMOST
----------------------------------------

(169) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   true => 1
   false => 0

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

(170)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 2 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 2 }-> if(lt(x, double(1 + double(1 + (1 + 0)))), x) :|: x >= 0, z = x
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(x)) :|: x >= 0, z = 1 + x
   if(z, z') -{ 2 }-> double(if(lt(1 + x, 10'), 1 + x)) :|: z' = x, z = 1, x >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' = x, x >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   lt(z, z') -{ 1 }-> 1 :|: z' = 1 + y, y >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0


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

(171) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(172)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 2 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 2 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0


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

(173) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { double }
   { lt }
   { 10' }
   { if }
   { 1024_1 }
   { 1024' }

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

(174)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 2 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 2 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {double}, {lt}, {10'}, {if}, {1024_1}, {1024'}

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

(175) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(176)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 2 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 2 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {double}, {lt}, {10'}, {if}, {1024_1}, {1024'}

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

(177) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: double
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2*z

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

(178)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 2 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 2 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {double}, {lt}, {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: ?, size: O(n^1) [2*z]

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

(179) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: double
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 1 + z

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

(180)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 2 }-> double(1 + (1 + (1 + double(1 + 0)))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 2 }-> if(lt(z, double(1 + double(1 + (1 + 0)))), z) :|: z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(z - 1)) :|: z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {lt}, {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]

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

(181) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(182)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 7 + s }-> if(lt(z, s'), z) :|: s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {lt}, {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]

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

(183) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: lt
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

(184)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 7 + s }-> if(lt(z, s'), z) :|: s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {lt}, {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: ?, size: O(1) [1]

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

(185) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: lt
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 2 + z'

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

(186)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 7 + s }-> if(lt(z, s'), z) :|: s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]

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

(187) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(188)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 9 + s + s' }-> if(s3, z) :|: s3 >= 0, s3 <= 1, s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 2 + z' }-> s4 :|: s4 >= 0, s4 <= 1, z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]

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

(189) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: 10'
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 10

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

(190)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 9 + s + s' }-> if(s3, z) :|: s3 >= 0, s3 <= 1, s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 2 + z' }-> s4 :|: s4 >= 0, s4 <= 1, z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {10'}, {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]
  10': runtime: ?, size: O(1) [10]

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

(191) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: 10'
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 10

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

(192)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 9 + s + s' }-> if(s3, z) :|: s3 >= 0, s3 <= 1, s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 2 }-> double(if(lt(1 + z', 10'), 1 + z')) :|: z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 2 + z' }-> s4 :|: s4 >= 0, s4 <= 1, z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]
  10': runtime: O(1) [10], size: O(1) [10]

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

(193) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(194)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 9 + s + s' }-> if(s3, z) :|: s3 >= 0, s3 <= 1, s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 14 + s5 }-> double(if(s6, 1 + z')) :|: s5 >= 0, s5 <= 10, s6 >= 0, s6 <= 1, z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 2 + z' }-> s4 :|: s4 >= 0, s4 <= 1, z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]
  10': runtime: O(1) [10], size: O(1) [10]

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

(195) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: if
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

(196)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 9 + s + s' }-> if(s3, z) :|: s3 >= 0, s3 <= 1, s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 14 + s5 }-> double(if(s6, 1 + z')) :|: s5 >= 0, s5 <= 10, s6 >= 0, s6 <= 1, z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 2 + z' }-> s4 :|: s4 >= 0, s4 <= 1, z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]
  10': runtime: O(1) [10], size: O(1) [10]
  if: runtime: ?, size: INF

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

(197) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: if
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

(198)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 8 + s1 }-> s2 :|: s1 >= 0, s1 <= 2 * (1 + 0), s2 >= 0, s2 <= 2 * (1 + (1 + (1 + s1)))
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 9 + s + s' }-> if(s3, z) :|: s3 >= 0, s3 <= 1, s >= 0, s <= 2 * (1 + (1 + 0)), s' >= 0, s' <= 2 * (1 + s), z >= 0
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 + z }-> 1 + (1 + s'') :|: s'' >= 0, s'' <= 2 * (z - 1), z - 1 >= 0
   if(z, z') -{ 14 + s5 }-> double(if(s6, 1 + z')) :|: s5 >= 0, s5 <= 10, s6 >= 0, s6 <= 1, z = 1, z' >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' >= 0, z = 0
   lt(z, z') -{ 2 + z' }-> s4 :|: s4 >= 0, s4 <= 1, z - 1 >= 0, z' - 1 >= 0
   lt(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0

Function symbols to be analyzed: {if}, {1024_1}, {1024'}
Previous analysis results are:
  double: runtime: O(n^1) [1 + z], size: O(n^1) [2*z]
  lt: runtime: O(n^1) [2 + z'], size: O(1) [1]
  10': runtime: O(1) [10], size: O(1) [10]
  if: runtime: INF, size: INF

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

(199) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:
none

And the following fresh constants: none

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

(200)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   1024' -> 1024_1(0) [1]
   1024_1(x) -> if(lt(x, 10'), x) [1]
   if(true, x) -> double(1024_1(s(x))) [1]
   if(false, x) -> s(0) [1]
   lt(0, s(y)) -> true [1]
   lt(x, 0) -> false [1]
   lt(s(x), s(y)) -> lt(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   10' -> double(s(double(s(s(0))))) [1]

The TRS has the following type information:
1024' :: 0:s
1024_1 :: 0:s -> 0:s
0 :: 0:s
if :: true:false -> 0:s -> 0:s
lt :: 0:s -> 0:s -> true:false
10' :: 0:s
true :: true:false
double :: 0:s -> 0:s
s :: 0:s -> 0:s
false :: true:false

Rewrite Strategy: INNERMOST
----------------------------------------

(201) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   true => 1
   false => 0

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

(202)
Obligation:
Complexity RNTS consisting of the following rules:

   10' -{ 1 }-> double(1 + double(1 + (1 + 0))) :|: 
   1024' -{ 1 }-> 1024_1(0) :|: 
   1024_1(z) -{ 1 }-> if(lt(x, 10'), x) :|: x >= 0, z = x
   double(z) -{ 1 }-> 0 :|: z = 0
   double(z) -{ 1 }-> 1 + (1 + double(x)) :|: x >= 0, z = 1 + x
   if(z, z') -{ 1 }-> double(1024_1(1 + x)) :|: z' = x, z = 1, x >= 0
   if(z, z') -{ 1 }-> 1 + 0 :|: z' = x, x >= 0, z = 0
   lt(z, z') -{ 1 }-> lt(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   lt(z, z') -{ 1 }-> 1 :|: z' = 1 + y, y >= 0, z = 0
   lt(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0

Only complete derivations are relevant for the runtime complexity.